Det här sätter du upp
OpenBao är en hemlighetshanterare: ett ställe för de lösenord, API-nycklar och certifikat som dina servrar och appar behöver, i stället för att de ligger utspridda i konfigurationsfiler, chattmeddelanden och kalkylark. Varje person och varje app loggar in, och en policy avgör vilka hemligheter de får läsa. Varje hemlighet sparar sina gamla versioner, och en granskningslogg visar vem som läste eller ändrade vad.
Allt OpenBao lagrar är krypterat med en nyckel som inte finns på disken. Efter varje start är OpenBao förseglad: den vet var dess data ligger men kan inte läsa den förrän tillräckligt många personer har matat in sin del av nyckeln. Det är priset för upplägget, och steg 6 visar hur det fungerar i praktiken.
OpenBao är en utgrening av HashiCorp Vault, startad 2023 från Vault 1.14, den sista versionen under en licens för öppen källkod. Så här ser det ut den 14 oktober 2026:
- Licens och ägare. OpenBao är öppen källkod under Mozilla Public License 2.0 och drivs av sina användare och utvecklare som ett projekt inom Linux Foundation, under OpenSSF. Vault ligger sedan version 1.15 under Business Source License 1.1. Den tillåter användning i produktion, men inte att du erbjuder Vault till andra som en konkurrerande tjänst eller inbyggd produkt, och den är ingen licens för öppen källkod. HashiCorp, och därmed Vault, ägs sedan februari 2025 av IBM.
- Versioner. De senaste är OpenBao 2.7.1, från 1 oktober 2026, och Vault 2.1.2, från 7 oktober 2026. Båda har utvecklats sedan utgreningen, så de är inte längre samma program.
- Funktioner. OpenBao har namnrymder (namespaces), som delar upp en server mellan flera team eller kunder, utan kostnad; i Vault är de en Enterprise-funktion. Vault Enterprise har replikering mellan datacenter och Sentinel-policyer, som OpenBao saknar. OpenBao har flyttat ut molnintegrationerna, för AWS, Azure och Google Cloud, och sedan 2.7 även inloggning via LDAP, Kerberos och RADIUS, ur huvudprogrammet till tillägg som du installerar separat.
- Kompatibilitet. OpenBao behåller Vaults API, ända ner till headern
X-Vault-Token, och dess kommandoradsverktyg heterbaoi stället förvault.
Här körs OpenBao från sin officiella avbild, i Podman under en egen användare som heter openbao, med sin data i en volym, bakom Caddy från Podman-guiden, som sköter HTTPS.
Varje steg nedan har körts på en nyinstallerad Melonslab VC-P Alloy (2 vCPU, 8 GB) med Debian 13:
- OpenBao 2.7.1 initierades med tre nyckeldelar, varav två låser upp den, och låstes upp både på servern och i webbgränssnittet efter varje omstart.
- Ett administratörskonto och ett teamkonto skapades med egna policyer, och root-token återkallades. Teamkontot kunde läsa och ändra teamets hemligheter och fick "permission denied" överallt annars.
- En hemlighet fick tre versioner, rullades tillbaka till den första, raderades och återställdes. Gamla versioner sparades, upp till tio per hemlighet.
- En PostgreSQL-container hämtade sitt lösenord från OpenBao via AppRole varje gång den startade. Efter en omstart av servern, med OpenBao fortfarande förseglad, startade den med lösenordet från förra gången. Appens inloggning nekades från alla adresser utom serverns egen.
- Granskningsloggen registrerade varje anrop med besökarens riktiga adress, över IPv4 och IPv6, och med hemliga värden utbytta mot hashar.
- Automatisk upplåsning med en statisk nyckel slogs på, klarade en omstart av servern och slogs av igen.
- En säkerhetskopia återställdes till en tom instans, och hemligheterna, användarna och policyerna kom tillbaka. En uppdatering från OpenBao 2.6.4 till 2.7.1 behöll all data.
OpenBao använde mellan 20 och 40 MB minne.
Innan du börjar
Du behöver:
- en server uppsatt som i Podman-guiden, med Caddy igång;
- en A-post och en AAAA-post för
bao.example.comsom pekar på din server; - två eller tre personer som var och en ska förvara en nyckeldel. Läs steg 5 innan du börjar, så att de är redo.
Exemplen använder bao.example.com för OpenBao, 203.0.113.10 och 2001:db8::10 för serverns IPv4- och IPv6-adress, som ip -brief address show eth0 visar, och anna och erik för två personer i ditt team. Byt ut dem genomgående.
1. Skapa användaren
Som root:
useradd -m -s /bin/bash openbao
loginctl enable-linger openbao
machinectl shell openbao@
Allt fram till steg 4 körs som openbao.
2. Skriv konfigurationen
Skapa ~/openbao.hcl:
ui = true
api_addr = "https://bao.example.com"
cluster_addr = "https://127.0.0.1:8201"
disable_mlock = true
storage "raft" {
path = "/openbao/data"
node_id = "bao1"
}
listener "tcp" {
address = "0.0.0.0:8200"
# Caddy handles HTTPS. The port is only reachable from this server.
tls_disable = true
x_forwarded_for_authorized_addrs = "203.0.113.10"
}
audit "file" "file" {
options {
file_path = "/openbao/logs/audit.log"
}
}
Vad inställningarna gör:
ui = trueslår på webbgränssnittet, påhttps://bao.example.com/ui/.storage "raft"är OpenBaos inbyggda lagring, som kallas integrated storage. Den sparar allt, krypterat, i en katalog, här i en volym, och behöver ingen databas. Fler servrar kan ansluta senare för hög tillgänglighet.api_addrär adressen som OpenBao ger klienter till sig själv, alltså den publikahttps://-adressen.cluster_addrär där servrarna i ett kluster pratar med varandra, på port 8201. Integrated storage kräver den även med en enda server, och med en server pratar den bara med sig själv, så127.0.0.1inne i containern är rätt. Port 8201 publiceras inte.tls_disableär säkert här eftersom OpenBao bara lyssnar på127.0.0.1på servern (steg 3), och Caddy krypterar allt som lämnar den.x_forwarded_for_authorized_addrslåter OpenBao lita på att Caddy anger varje besökares riktiga adress. Caddys anslutningar når containern från serverns egen IPv4-adress, som Podman-guiden förklarar, så det är den du anger. Utan den visar granskningsloggen203.0.113.10för alla.disable_mlockär vad OpenBao rekommenderar med integrated storage. Det låter operativsystemet flytta OpenBaos minne till swap, vilket bara spelar roll om servern har swap.- Blocket
auditskriver granskningsloggen (steg 11). I OpenBao ställs granskningsloggar in i den här filen, inte med ett kommando.
3. Definiera containern
mkdir -p ~/.config/containers/systemd
Skapa ~/.config/containers/systemd/openbao.container:
[Unit]
Description=OpenBao
[Container]
ContainerName=openbao
Image=quay.io/openbao/openbao:2.7.1
Exec=server
Volume=%h/openbao.hcl:/openbao/config/openbao.hcl:ro
Volume=openbao-data:/openbao/data:U
Volume=openbao-audit:/openbao/logs:U
Environment=BAO_ADDR=http://127.0.0.1:8200
# Only Caddy, on this server, can reach OpenBao: the port is not open to the internet.
PublishPort=127.0.0.1:8174:8200
[Service]
Restart=always
[Install]
WantedBy=default.target
quay.io/openbao/openbaoär avbilden som OpenBao-projektet ger ut. Den kör OpenBao som en vanlig användare även inne i containern.Exec=serverstartar en riktig server med konfigurationen från steg 2. Utan den startar avbilden en utvecklingsserver som håller allt i minnet och tappar det när den stoppas.:Uger volymerna till OpenBaos användare inne i containern.BAO_ADDRlåter kommandotbaoinne i containern hitta servern.- Raden
AutoUpdatesaknas med flit: varje omstart förseglar OpenBao, så uppdateringar görs för hand (steg 14).
Starta den:
systemctl --user daemon-reload
systemctl --user start openbao
podman exec openbao bao status
Initialized false och Sealed true betyder att den är igång och väntar på steg 5. Avbilden är omkring 190 MB.
Lägg till ett kortkommando, så slipper du skriva podman exec före varje bao-kommando:
echo "alias bao='podman exec -i -e BAO_TOKEN openbao bao'" >> ~/.bashrc
source ~/.bashrc
-e BAO_TOKEN skickar med din inloggning, som du håller i variabeln BAO_TOKEN i ditt eget skal, till varje kommando.
4. Sätt Caddy framför
Gå tillbaka till root med exit, byt till machinectl shell caddy@ och lägg till det här blocket sist i ~/Caddyfile:
bao.example.com {
reverse_proxy 127.0.0.1:8174
}
Starta om Caddy med systemctl --user restart caddy. https://bao.example.com/ui/ visar nu en sida för att sätta upp OpenBao. Använd den inte: gör steg 5 på servern i stället, direkt, så att ingen annan hinner före.
5. Initiera: nyckeldelar och root-token
Gå tillbaka till root med exit och byt till machinectl shell openbao@ igen. Sedan:
podman exec -it openbao bao operator init -key-shares=3 -key-threshold=2
OpenBao skapar nyckeln som krypterar allt, delar upp den i tre nyckeldelar, där två valfria räcker för att låsa upp, och skriver ut dem tillsammans med en root-token:
Unseal Key 1: U6jUw5pF...
Unseal Key 2: KzPB2nCU...
Unseal Key 3: vLL92MWG...
Initial Root Token: s.1eTbozfb...
Det här är enda gången de visas. OpenBao sparar inte själva nyckeln, så tappar du bort för många nyckeldelar kan ingen läsa dina hemligheter igen, inte ens från en säkerhetskopia.
Var du förvarar dem:
- Ge varje nyckeldel till en egen person, som sparar den i sin egen lösenordshanterare. Två av tre betyder att två av er kan låsa upp OpenBao, att en nyckeldel kan försvinna eller en person vara borta utan problem, och att ingen kan göra det ensam.
- Spara aldrig nyckeldelarna i OpenBao, eftersom du behöver dem innan OpenBao går att läsa, och aldrig alla på samma ställe, som en delad mapp eller ett och samma mejl.
- Är du ensam administratör håller du ändå isär dem: en i din lösenordshanterare, en utskriven i ett kassaskåp, en hos någon du litar på.
- Spara root-token bara fram till steg 8, på ett ställe där du kan radera den efteråt.
Root-token kan göra allt, går aldrig ut och struntar i alla policyer. Allt den gör loggas som "root", inte som en person. Steg 8 skapar administratörskonton i personernas egna namn och återkallar den sedan. Behöver du en root-token igen kan de som har nyckeldelarna skapa en ny tillsammans, som Felsökning beskriver.
6. Lås upp den, efter varje start
Lås upp OpenBao nu, genom att mata in två av nyckeldelarna:
podman exec -it openbao bao operator unseal
podman exec -it openbao bao operator unseal
Varje kommando frågar efter en nyckeldel utan att visa den. Efter den andra är Sealed false.
OpenBao förseglas igen varje gång den startar: efter en omstart av servern, en omstart av containern och en uppdatering. Tills två personer med nyckeldelar har låst upp den visar https://bao.example.com bara upplåsningssidan, och appar som frågar efter hemligheter får ett fel. De behöver inte SSH: var och en kan mata in sin nyckeldel på den sidan, under Unseal Key Portion, med Unseal, från sin egen dator. När den sista är inmatad byts sidan mot inloggningen.
Om omstarter sker när ingen finns till hands visar steg 12 hur OpenBao kan låsa upp sig själv, och vad det kostar.
7. Spara hemligheter
Logga in med root-token, som read -rs tar emot utan att visa den, och slå på ett lager för hemligheter:
read -rs BAO_TOKEN && export BAO_TOKEN
bao secrets enable -path=secret kv-v2
kv-v2 är OpenBaos nyckel/värde-lager med versioner. Varje hemlighet har en sökväg, som team/wifi, och innehåller ett eller flera fält:
bao kv put -mount=secret team/wifi ssid=Office password=first-pass
bao kv put -mount=secret team/wifi ssid=Office password=second-pass
bao kv get -mount=secret team/wifi
Varje put skapar en ny version, och OpenBao sparar de tio senaste. Så läser du en gammal version och gör den till den aktuella igen:
bao kv get -mount=secret -version=1 team/wifi
bao kv rollback -mount=secret -version=1 team/wifi
rollback kopierar version 1 till en ny version 3, så inget går förlorat. bao kv delete döljer den aktuella versionen, och bao kv undelete -versions=3 tar tillbaka den. Bara bao kv destroy, och bao kv metadata delete för alla versioner på en gång, tar bort data för gott.
Ett lösenord i ett kommando hamnar i skalets historik. För riktiga lösenord använder du webbgränssnittet (steg 9), eller låter OpenBao skapa värdet, som steg 10 gör.
8. Policyer och personer
En policy listar de sökvägar en inloggning får använda, och vad den får göra där. Skapa en för teamet, som får läsa och ändra allt under team/:
bao policy write team - <<'EOF'
path "secret/data/team/*" {
capabilities = ["create", "read", "update", "patch", "delete"]
}
path "secret/metadata/team/*" {
capabilities = ["read", "list"]
}
path "secret/undelete/team/*" {
capabilities = ["update"]
}
path "secret/metadata/" {
capabilities = ["list"]
}
EOF
Och en för administratörer, som får göra allt, som root-token, men i sina egna namn:
bao policy write admin - <<'EOF'
path "*" {
capabilities = ["create", "read", "update", "patch", "delete", "list", "sudo"]
}
EOF
Personer loggar in med användarnamn och lösenord, med metoden userpass. Slå på den, med inloggningar som gäller i åtta timmar:
bao auth enable userpass
bao auth tune -default-lease-ttl=8h -max-lease-ttl=24h userpass/
Skapa sedan ett konto för varje person, med ett slumpat lösenord som du ger dem:
PW=$(openssl rand -base64 18); echo "$PW"
printf %s "$PW" | bao write auth/userpass/users/anna token_policies=admin password=-
PW=$(openssl rand -base64 18); echo "$PW"
printf %s "$PW" | bao write auth/userpass/users/erik token_policies=team password=-
Skapa minst två administratörer, så att ett bortglömt lösenord inte låser ute er. För att byta lösenord senare kör du samma bao write-rad för användaren med ett nytt.
Logga nu in som administratör, i stället för med root-token:
read -rsp 'Password: ' PW; echo
export BAO_TOKEN=$(printf %s "$PW" | bao login -method=userpass -token-only -no-store username=anna password=-)
bao token lookup
display_name visar userpass-anna. Återkalla sedan root-token. Klistra in den efter första raden:
read -rs ROOT
BAO_TOKEN=$ROOT bao token revoke -self
unset ROOT PW
Radera root-token där du sparade den i steg 5. Från och med nu har allt i granskningsloggen en persons namn.
OpenBao kan också lämna inloggningen till en tjänst för gemensam inloggning, som authentik, över OpenID Connect, med bao auth enable oidc. Det testade vi inte här.
9. Webbgränssnittet
Öppna https://bao.example.com/ui/. Välj Username under Method och logga in med ditt användarnamn och lösenord. Du ser de lager som din policy tillåter, här secret/.
Öppna secret/, sedan team/ och wifi. Värdena är dolda tills du väljer ögat bredvid dem. Create new version ändrar hemligheten, och versionsmenyn, här Version 3, har View version history och View diff. Create secret i en mapp lägger till en ny, vilket är det bästa sättet att skriva in ett riktigt lösenord, eftersom det inte hamnar i någon historik.
En teammedlem som öppnar en hemlighet utanför team/ ser "You do not have permission to read this secret." Gränssnittet finns bara på engelska.
Den som hellre använder kommandoraden kan installera bao på sin egen dator och logga in därifrån:
export BAO_ADDR=https://bao.example.com
bao login -method=userpass username=erik
10. Låt en app hämta sitt lösenord
Appar loggar in med AppRole, en metod för maskiner: varje app får ett role ID, som ett användarnamn, och ett secret ID, som ett lösenord. Här hämtar en PostgreSQL-databas för en webbutik sitt lösenord från OpenBao varje gång den startar, så att lösenordet förvaras och byts på ett ställe.
Som openbao, inloggad som administratör, skapar du en policy som bara låter butiken läsa sina egna hemligheter, sparar ett slumpat databaslösenord och skapar rollen:
bao policy write shop - <<'EOF'
path "secret/data/apps/shop/*" {
capabilities = ["read"]
}
EOF
bao kv put -mount=secret apps/shop/db password="$(openssl rand -hex 24)"
bao auth enable approle
bao write auth/approle/role/shop token_policies=shop token_ttl=5m token_max_ttl=10m \
secret_id_bound_cidrs=203.0.113.10/32,2001:db8::10/128
bao read -field=role_id auth/approle/role/shop/role-id; echo
bao write -f -field=secret_id auth/approle/role/shop/secret-id; echo
De två sista raderna skriver ut role ID och secret ID; ha dem till hands en stund. secret_id_bound_cidrs godtar bara secret ID från butikens server, här den här, över IPv4 och IPv6: ett kopierat secret ID nekas från alla andra adresser med "unauthorized by CIDR restrictions". Körs appen på en annan server anger du dess adresser. Inloggningen den får gäller i fem minuter.
Appen behöver jq för att läsa OpenBaos svar. Installera det som root och skapa en användare för butiken:
apt install -y jq
useradd -m -s /bin/bash shop
loginctl enable-linger shop
machinectl shell shop@
Spara de två id:na som shop. Kör varje cat-rad, klistra in id:t, tryck Enter och sedan Ctrl-D:
mkdir -p ~/.config/bao ~/.config/containers/systemd
chmod 700 ~/.config/bao
cat > ~/.config/bao/role-id
cat > ~/.config/bao/secret-id
Skapa ~/fetch-db-password, som loggar in, hämtar lösenordet, sparar det som en Podman-hemlighet och loggar ut:
#!/bin/sh
# Log in to OpenBao as the shop, and store its database password as a Podman secret.
set -e
BAO=https://bao.example.com
TOKEN=$(jq -n --arg r "$(cat ~/.config/bao/role-id)" --arg s "$(cat ~/.config/bao/secret-id)" '{role_id: $r, secret_id: $s}' \
| curl -sf -d @- $BAO/v1/auth/approle/login | jq -r .auth.client_token)
curl -sf -H "X-Vault-Token: $TOKEN" $BAO/v1/secret/data/apps/shop/db \
| jq -j .data.data.password | podman secret create --replace shop-db-password -
curl -sf -X POST -H "X-Vault-Token: $TOKEN" $BAO/v1/auth/token/revoke-self
chmod 700 ~/fetch-db-password
Och ~/.config/containers/systemd/shop-db.container:
[Unit]
Description=The shop's database
[Container]
ContainerName=shop-db
Image=docker.io/library/postgres:17
Volume=shop-db:/var/lib/postgresql/data
Environment=POSTGRES_USER=shop POSTGRES_DB=shop
Secret=shop-db-password,type=env,target=POSTGRES_PASSWORD
[Service]
# Fetch the password from OpenBao first. If that fails, the password from last time is used.
ExecStartPre=-%h/fetch-db-password
Restart=always
[Install]
WantedBy=default.target
Starta den:
systemctl --user daemon-reload
systemctl --user start shop-db
Första starten laddar ner PostgreSQL och sätter upp databasen, vilket tar några sekunder. Kontrollera sedan att lösenordet från OpenBao fungerar:
podman exec shop-db sh -c 'PGPASSWORD="$POSTGRES_PASSWORD" psql -h "$(hostname -i)" -U shop -c "select current_user"'
current_user är shop. Kontrollen ansluter till containerns nätverksadress, eftersom PostgreSQL släpper in anslutningar från 127.0.0.1 i sin egen container utan lösenord. Med fel lösenord får samma kommando "password authentication failed".
Själva appen, i en container bredvid databasen, får samma lösenord med samma Secret=-rad, som DB_PASSWORD i BookStack-guiden.
Tecknet - före ExecStartPre spelar roll: efter en omstart av servern är OpenBao förseglad tills någon låser upp den, och hämtningen misslyckas. Databasen startar då med lösenordet från förra gången, som Podman sparar i användarens hemkatalog. Utan - skulle butiken ligga nere tills OpenBao var upplåst.
För att byta lösenord lägger du in ett nytt i OpenBao, byter det i databasen också och startar om:
podman exec shop-db psql -U shop -c "ALTER USER shop PASSWORD 'the-new-password'"
systemctl --user restart shop-db
PostgreSQL läser bara POSTGRES_PASSWORD när databasen skapas, så ALTER USER behövs. OpenBao kan också skapa databasinloggningar själv, en ny för varje gång appen startar, med sin motor för databashemligheter. Det testade vi inte här.
11. Granskningsloggen
Granskningsloggen från steg 2 registrerar varje anrop och varje svar, en JSON-rad var: tiden, sökvägen, vem som frågade, från vilken adress och om det var tillåtet. Som openbao:
podman exec openbao tail -n 2 /openbao/logs/audit.log
Hemliga värden och token visas som hmac-sha256:-hashar, aldrig i klartext, så loggen är säker att läsa och att skicka vidare. remote_address är besökarens riktiga adress, över IPv4 och IPv6, tack vare raden x_forwarded_for_authorized_addrs.
OpenBao nekar anrop som den inte kan skriva till granskningsloggen, så en full disk stoppar den. Loggen växer med en eller två kilobyte per anrop. För att börja på en ny fil flyttar du den gamla och ber OpenBao öppna filen på nytt:
podman exec openbao mv /openbao/logs/audit.log /openbao/logs/audit.log.1
podman kill --signal HUP openbao
12. Lås upp automatiskt (valfritt)
I stället för personer med nyckeldelar kan OpenBao hämta sin nyckel någon annanstans vid varje start, så kallad auto-unseal. Valen:
- Transit: en annan OpenBao-server har nyckeln och låser upp den här. Nyckeln finns inte på den här servern, men den andra måste vara igång och upplåst först.
- KMS: en nyckeltjänst, som AWS KMS, Azure Key Vault eller en HSM, via ett tillägg. Inte heller här finns nyckeln på servern.
- Statisk nyckel: en nyckel du själv ger OpenBao, till exempel en fil. Enkelt, men nyckeln ligger på samma server som datan.
Vi testade den statiska nyckeln. Läs vad du ger upp först: den som kan läsa nyckelfilen kan dekryptera allt, så den som får root på servern, eller en fullständig kopia av dess disk, från en ögonblicksbild av disken eller en slarvig säkerhetskopia av hemkatalogen, kan läsa alla dina hemligheter. Med nyckeldelar i personers huvuden och lösenordshanterare är en kopierad disk värdelös. Den statiska nyckeln skyddar bara mot den som tar datan utan nyckeln, och gör omstarter och automatiska uppdateringar helt självgående. Den passar en server där bekvämligheten är värd mer än den skillnaden.
Skapa nyckeln som en Podman-hemlighet, som openbao:
openssl rand 32 | podman secret create openbao-unseal-key -
Lägg till Secret=openbao-unseal-key under [Container] i openbao.container, och det här blocket sist i ~/openbao.hcl:
seal "static" {
current_key_id = "key-1"
current_key = "file:///run/secrets/openbao-unseal-key"
}
Starta om och byt OpenBao till den nya upplåsningen med två av dina nyckeldelar:
systemctl --user daemon-reload
systemctl --user restart openbao
podman exec -it openbao bao operator unseal -migrate
podman exec -it openbao bao operator unseal -migrate
Från och med nu visar bao status Seal Type static, och OpenBao låser upp sig själv när den startar. Nyckeldelarna är nu återställningsnycklar: de låser inte längre upp något, men du behöver dem fortfarande för att skapa en ny root-token, så behåll dem.
För att gå tillbaka lägger du till disabled = "true" i blocket seal "static", startar om, kör de två unseal -migrate-kommandona igen med nyckeldelarna och tar sedan bort blocket, raden Secret= och hemligheten.
13. Säkerhetskopiera
En säkerhetskopia av OpenBao är en ögonblicksbild (snapshot) av dess integrated storage: varje hemlighet, version, användare, policy och AppRole. Hemligheterna i den är fortfarande krypterade och kan bara läsas med era nyckeldelar, så en ögonblicksbild är värdelös utan dem, och nyckeldelarna förvaras ju separat.
Som openbao, inloggad som administratör, skapar du en policy och en inloggning för säkerhetskopior, som får ta ögonblicksbilder och inget annat:
bao policy write backup - <<'EOF'
path "sys/storage/raft/snapshot" {
capabilities = ["read"]
}
EOF
umask 077
bao token create -policy=backup -orphan -period=720h -display-name=backup -field=token > ~/.bao-backup-token
Sedan säkerhetskopierar du så här:
umask 077
mkdir -p ~/backup
curl -sf -X POST -H "X-Vault-Token: $(cat ~/.bao-backup-token)" http://127.0.0.1:8174/v1/auth/token/renew-self > /dev/null
curl -sf -H "X-Vault-Token: $(cat ~/.bao-backup-token)" -o ~/backup/openbao.snap http://127.0.0.1:8174/v1/sys/storage/raft/snapshot
cp ~/openbao.hcl ~/.config/containers/systemd/openbao.container ~/backup/
Inloggningen för säkerhetskopior går ut om den inte förnyas inom 30 dagar, vilket den första curl-raden gör, så kör raderna minst så ofta, till exempel dagligen. Kopiera ~/backup till en annan maskin, till exempel med restic. Ögonblicksbilden fungerar bara medan OpenBao är upplåst.
För att återställa på en ny server sätter du upp OpenBao som i steg 1 till 4, med filerna från säkerhetskopian. Som openbao initierar du sedan den tomma instansen med en tillfällig nyckel, som bara finns fram till återställningen:
podman exec openbao bao operator init -key-shares=1 -key-threshold=1
podman exec -it openbao bao operator unseal
read -rs BAO_TOKEN && export BAO_TOKEN
curl -sf -X POST -H "X-Vault-Token: $BAO_TOKEN" --data-binary @$HOME/backup/openbao.snap http://127.0.0.1:8174/v1/sys/storage/raft/snapshot-force
unset BAO_TOKEN
Lås upp med den tillfälliga nyckeln och klistra in den tillfälliga root-token vid read. Efter återställningen är OpenBao förseglad igen, nu med er gamla nyckel: lås upp med två av era egna nyckeldelar som i steg 6 och logga in med era vanliga konton. Den tillfälliga nyckeln och token gäller inte längre.
14. Uppdatera
Versionen är låst i openbao.container, eftersom varje uppdatering startar om OpenBao, och varje omstart förseglar den. Uppdatera när någon kan låsa upp den direkt efteråt. Läs versionsinformationen på OpenBaos GitHub först; säkerhetsrättningar är markerade där.
Som openbao tar du en säkerhetskopia som i steg 13, byter versionen på raden Image=, till exempel till quay.io/openbao/openbao:2.7.2, och startar om:
systemctl --user daemon-reload
systemctl --user restart openbao
Lås sedan upp den som i steg 6. OpenBao uppdaterar sin data själv när den startar. bao status visar den nya versionen.
Med en statisk nyckel från steg 12 låser OpenBao upp sig själv efter uppdateringar. Då kan du lägga till AutoUpdate=registry med en tagg som 2.7, som följer versionerna i 2.7, och slå på podman-auto-update.timer som i Podman-guiden.
Felsökning
Anrop misslyckas med "Vault is sealed", eller sidan visar upplåsningssidan. OpenBao har startat om, efter en omstart av servern eller en uppdatering. Lås upp den som i steg 6.
Varje rad i granskningsloggen har serverns egen adress. x_forwarded_for_authorized_addrs i ~/openbao.hcl saknas eller är fel. Den måste vara serverns IPv4-adress. Rätta den, starta om OpenBao och lås upp den.
"cannot enable audit device via API". OpenBao tar bara granskningsloggar från sin konfigurationsfil. Lägg till ett audit-block som i steg 2 och starta om.
Appens hämtning misslyckas med "unauthorized by CIDR restrictions". Appen ansluter från en adress som secret_id_bound_cidrs inte listar. Över IPv6 använder servern sin IPv6-adress, så lista båda. Rätta det med samma bao write auth/approle/role/shop-rad, som behåller role ID, och skapa ett nytt secret ID.
bao säger "permission denied" om allt. BAO_TOKEN är tom eller har gått ut, efter åtta timmar för en person. Logga in igen som i steg 8.
Alla administratörer har glömt sina lösenord. De som har nyckeldelarna kan skapa en ny root-token tillsammans. Det kräver ett äldre sätt som OpenBao stänger av som standard, eftersom vem som helst annars kunde starta eller avbryta det. Lägg till disable_unauthed_generate_root_endpoints = false i blocket listener i ~/openbao.hcl, starta om OpenBao och lås upp den. Sedan, som openbao:
OTP=$(tr -dc A-Za-z0-9 </dev/urandom | head -c 26)
NONCE=$(curl -s -X PUT -d "{\"otp\":\"$OTP\"}" http://127.0.0.1:8174/v1/sys/generate-root/attempt | jq -r .nonce)
read -rs KEY; curl -s -X PUT -d "{\"key\":\"$KEY\",\"nonce\":\"$NONCE\"}" http://127.0.0.1:8174/v1/sys/generate-root/update | jq -r .encoded_token
read -rs KEY; ENC=$(curl -s -X PUT -d "{\"key\":\"$KEY\",\"nonce\":\"$NONCE\"}" http://127.0.0.1:8174/v1/sys/generate-root/update | jq -r .encoded_token)
python3 -c 'import base64,sys; e=base64.b64decode(sys.argv[1]+"=="); print(bytes(a^b for a,b in zip(e,sys.argv[2].encode())).decode())' "$ENC" "$OTP"
Klistra in en nyckeldel vid varje read. Den sista raden skriver ut en ny root-token. Använd den för att ge någon ett nytt lösenord som i steg 8, återkalla den, ta sedan bort raden från ~/openbao.hcl igen och starta om. jq installeras i steg 10. 26 är längden på en token i OpenBao, som root-token från steg 5.