Kör Ansible-playbooks från ett webbgränssnitt med Semaphore och Podman utan root

Det här sätter du upp

Semaphore UI är ett webbgränssnitt för att köra Ansible-playbooks. Dina playbooks ligger kvar i Git; Semaphore håller reda på SSH-nycklarna, listorna över servrar och variablerna, och vem som helst i teamet kan starta en playbook med en knapp, följa utskriften medan den körs och gå tillbaka till varje tidigare körning. Den kan också köra playbooks enligt ett schema, fråga efter värden före en körning, larma när en körning misslyckas och starta körningar från ett skript via sitt API. Terraform, OpenTofu och skalskript körs på samma sätt.

Semaphore UI startade 2014 som Ansible Semaphore och utvecklas i dag av Denis Gukov och Semaphore UI-teamet, som anger Serbien som hemvist på GitHub. Källkoden är öppen under MIT-licensen. Den 14 oktober 2026 listade Semaphores prissida en betald Pro-utgåva, från 20 dollar i månaden, med runners per projekt, körningar i Docker-containrar, en lagringsplats för Terraform-tillstånd, hemligheter från HashiCorp Vault och OpenBao, LDAP och enkel inloggning samt tvåfaktorsinloggning; och en Enterprise-utgåva, med pris på förfrågan, med egna roller, Kubernetes och hög tillgänglighet. Tvåfaktorsinloggning fungerade i den fria versionen vi testade, som steg 6 visar. Projektet ger ut två avbilder: semaphoreui/semaphore-community, byggd enbart från den öppna källkoden, och semaphoreui/semaphore, som även innehåller den stängda Pro-koden och väntar på en licensnyckel. Den här guiden använder community-avbilden. I våra tester gjorde den inga egna anslutningar utåt.

Här körs Semaphore som en pod under en egen användare som heter semaphore, med PostgreSQL för dess data, bakom Caddy från Podman-guiden. Semaphore stöder PostgreSQL, MySQL (eller MariaDB) och SQLite; BoltDB, dess gamla standard, stöds inte längre sedan version 2.19.

Varje steg nedan har körts på en nyinstallerad Melonslab VC-P Alloy (2 vCPU, 8 GB) med Debian 13:

• Semaphore UI 2.19.16 startade med PostgreSQL 18, och den första administratören skapades på kommandoraden innan Caddy sattes upp. Det finns ingen sida för registrering.
• En playbook i ett Git-förråd på servern kördes mot servern själv, över SSH, som en vanlig användare. En fråga som ställdes före körningen nådde fram till playbooken, och utskriften visade varje steg.
• Ett schema körde playbooken på utsatt tid, i svensk tid.
• En kollega med rollen Guest kunde läsa körningarna och deras utskrift, men inte starta en körning eller ändra något.
• Tvåfaktorsinloggning med en tidsbaserad engångskod fungerade för en användare.
• En misslyckad körning skickade ett larm via e-post, som fångades av en testserver för e-post på samma server.
• En körning startades med curl och en API-token.
• En avlyssning av serverns trafik visade inga anslutningar utåt medan Semaphore startade, körde playbooks och visade webbgränssnittet.
• En uppdatering från 2.19.15 till 2.19.16 gick igenom genom att byta avbildens tagg. Semaphore återställdes från en säkerhetskopia till en ny, tom installation, och allt startade igen av sig självt efter en omstart av servern.

Podden använde omkring 45 MB minne i vila och omkring 160 MB medan en playbook kördes mot en server.

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 ops.example.com som pekar på din server.

Exemplen använder ops.example.com för Semaphore, anna för ditt eget konto och deploy för användaren som Semaphore loggar in som på servrarna den sköter. Här är servern som sköts samma server, så att du kan prova allt på en maskin; steg 8 visar hur du lägger till fler. Byt ut namnen genomgående.

1. Skapa användaren

Som root:

useradd -m -s /bin/bash semaphore
loginctl enable-linger semaphore
machinectl shell semaphore@

Allt fram till steg 5 körs som semaphore.

2. Skapa hemligheterna

openssl rand -hex 24 | tr -d '\n' | podman secret create semaphore-db-password -
for s in access-key-encryption cookie-hash cookie-encryption; do
  openssl rand -base64 32 | tr -d '\n' | podman secret create semaphore-$s -
done

Den första raden skapar databaslösenordet. Loopen skapar tre nycklar: access-key-encryption krypterar SSH-nycklarna och lösenorden du sparar i Semaphore, och de två cookie-nycklarna signerar och krypterar inloggningar. Utan den första nyckeln innehåller en återställd databas nycklar som ingen kan läsa, så steg 15 sparar en kopia av alla tre. Podman lagrar dem, inte filerna nedan.

3. Definiera podden

mkdir -p ~/.config/containers/systemd ~/repos
cd ~/.config/containers/systemd

Skapa semaphore.pod:

[Pod]
PodName=semaphore
# Semaphore's user in the container (1001) is the semaphore user on the server.
UserNS=keep-id:uid=1001,gid=1001
# Only Caddy, on this server, can reach Semaphore: the port is not open to the internet.
PublishPort=127.0.0.1:8183:3000

[Install]
WantedBy=default.target

Skapa semaphore-db.container:

[Container]
ContainerName=semaphore-db
Image=docker.io/library/postgres:18-alpine
Pod=semaphore.pod
Volume=semaphore-db:/var/lib/postgresql
Environment=POSTGRES_USER=semaphore POSTGRES_DB=semaphore
Secret=semaphore-db-password,type=env,target=POSTGRES_PASSWORD
HealthCmd=pg_isready -U semaphore
HealthInterval=10s
Notify=healthy
AutoUpdate=registry

[Service]
Restart=always

Och semaphore-app.container:

[Unit]
Requires=semaphore-db.service
After=semaphore-db.service

[Container]
ContainerName=semaphore-app
Image=docker.io/semaphoreui/semaphore-community:v2.19.16
Pod=semaphore.pod
Exec=/usr/local/bin/semaphore server --no-config
Volume=%h/repos:/repos:ro
Environment=SEMAPHORE_DB_DIALECT=postgres SEMAPHORE_DB_HOST=127.0.0.1:5432 SEMAPHORE_DB=semaphore SEMAPHORE_DB_USER=semaphore
Environment='SEMAPHORE_DB_OPTIONS={"sslmode":"disable"}'
Environment=SEMAPHORE_WEB_ROOT=https://ops.example.com
Environment=TZ=Europe/Stockholm SEMAPHORE_SCHEDULE_TIMEZONE=Europe/Stockholm
Environment=SEMAPHORE_TOTP_ENABLED=true
Secret=semaphore-db-password,type=env,target=SEMAPHORE_DB_PASS
Secret=semaphore-access-key-encryption,type=env,target=SEMAPHORE_ACCESS_KEY_ENCRYPTION
Secret=semaphore-cookie-hash,type=env,target=SEMAPHORE_COOKIE_HASH
Secret=semaphore-cookie-encryption,type=env,target=SEMAPHORE_COOKIE_ENCRYPTION

[Service]
Restart=always

Vad inställningarna gör:

• UserNS=keep-id gör Semaphores användare i containern till samma användare som semaphore på servern, så att Semaphore kan läsa Git-förråden du har i ~/repos, som den ser som /repos. Utan den vägrar Git att använda dem, eftersom de tillhör någon annan. PostgreSQL i samma pod körs också som den användaren.
• Exec=... --no-config startar Semaphore med inställningarna från raderna ovan och inget annat. Avbildens eget startskript skulle i stället skriva en config.json med databaslösenordet och egna nycklar.
• SEMAPHORE_DB_OPTIONS stänger av TLS mot databasen, som PostgreSQL i containern inte erbjuder. Anslutningen lämnar aldrig podden.
• SEMAPHORE_WEB_ROOT är den publika adressen. Semaphore använder den för varje sida och för länkarna i sina larm, och markerar inloggningens cookies som säkra eftersom den börjar med https.
• SEMAPHORE_SCHEDULE_TIMEZONE gör att scheman körs i svensk tid; Semaphores standard är UTC. TZ ställer in tiden i loggarna.
• SEMAPHORE_TOTP_ENABLED låter användare slå på tvåfaktorsinloggning (steg 6).
• Avbilden är låst till en version. Semaphore underhåller två versionsserier samtidigt, 2.18 och 2.19, och taggen latest pekade på 2.18.31 när vi testade, så en versionstagg är sättet att veta vad du kör. Steg 16 visar hur du uppdaterar. PostgreSQL ligger kvar på 18 och uppdateras av podman auto-update.

Starta den:

systemctl --user daemon-reload
systemctl --user start semaphore-pod
systemctl --user enable --now podman-auto-update.timer

Vid första starten laddas omkring 450 MB avbilder ner, som packas upp till omkring 1,7 GB. Semaphores avbild innehåller Ansible 13 (ansible-core 2.20), OpenTofu, Terraform, Git och Python.

4. Skapa den första administratören

Semaphore har ingen sida för att sätta upp den: det första kontot skapas på kommandoraden. Vänta tills Semaphore svarar, vilket också betyder att den har satt upp sin databas:

until curl -sf -o /dev/null http://127.0.0.1:8183/; do sleep 2; done

Skapa sedan ditt konto med ett slumpat lösenord:

pw=$(openssl rand -base64 18)
podman exec semaphore-app semaphore user add --no-config --admin --login anna --name "Anna Andersson" --email anna@example.com --password "$pw"
echo "$pw"

Det skriver ut User anna <anna@example.com> added! och lösenordet. Spara lösenordet i din lösenordshanterare. En SSH-tunnel skulle inte låta dig logga in innan Caddy är uppsatt: varje sida säger åt webbläsaren att hämta resten från https://ops.example.com, som inte svarar än.

Om du någon gång tappar bort lösenordet sätter du ett nytt på samma sätt:

podman exec semaphore-app semaphore user change-by-login --no-config --login anna --password 'a-new-long-password'

5. 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:

ops.example.com {
    reverse_proxy 127.0.0.1:8183
}

Starta om Caddy med systemctl --user restart caddy, öppna https://ops.example.com och logga in med anna och lösenordet från steg 4. Gränssnittet finns på 15 språk, men inte på svenska.

6. Kontrollera vem som kommer in

Semaphore har ingen sida för registrering och ingen offentlig åtkomst. Bara en administratör kan skapa konton, under Users (steg 11).

Semaphore begränsar inte antalet inloggningsförsök och loggar inte misslyckade försök: i vårt test nekades 30 felaktiga lösenord i rad utan vidare, och det rätta fungerade fortfarande. Använd långa, slumpade lösenord och slå på tvåfaktorsinloggning, som SEMAPHORE_TOTP_ENABLED från steg 3 tillåter. Varje användare gör det för sitt eget konto: öppna menyn med ditt namn längst ner till vänster, Edit Account, fliken Security, och slå på Time-based one-time password. Skanna QR-koden med en autentiseringsapp. Från och med nu frågar Semaphore efter en kod efter lösenordet.

Om en användare tappar bort sin telefon stänger du av det åt hen, som semaphore:

podman exec semaphore-app semaphore user totp disable --no-config --login erik

7. Lägg en playbook i Git

Semaphore kör playbooks från ett Git-förråd. Om dina playbooks redan ligger på GitHub, GitLab eller din egen Forgejo använder du det förrådet i steg 8. Här skapar du ett på servern, och en användare för Semaphore att sköta.

Som root installerar du Git, skapar användaren deploy och gör en SSH-nyckel som Semaphore loggar in som deploy med:

apt install -y git
useradd -m -s /bin/bash deploy
ssh-keygen -t ed25519 -N "" -C semaphore -f /root/semaphore-key
install -d -m 700 -o deploy -g deploy /home/deploy/.ssh
install -m 600 -o deploy -g deploy /root/semaphore-key.pub /home/deploy/.ssh/authorized_keys

deploy får ingen sudo, så playbooken nedan kan bara ändra sina egna filer. På en annan server lägger du till samma publika nyckel, /root/semaphore-key.pub, hos användaren som Semaphore ska logga in som där.

Som semaphore (machinectl shell semaphore@) skapar du sedan förrådet och en arbetskopia:

git config --global user.name "Anna Andersson"
git config --global user.email anna@example.com
git init --bare -b main ~/repos/ops.git
git clone ~/repos/ops.git ~/ops
cd ~/ops

Skapa ~/ops/site.yml, en playbook som visar det lediga diskutrymmet på varje server och skriver en anteckning:

- name: Check the servers
  hosts: all
  tasks:
    - name: Check free disk space
      ansible.builtin.command: df -h /
      register: disk
      changed_when: false

    - name: Print it
      ansible.builtin.debug:
        msg: "{{ ansible_facts.hostname }}: {{ disk.stdout_lines[1] }}"

    - name: Write a note in the home directory
      ansible.builtin.copy:
        dest: "~/semaphore-note.txt"
        content: "{{ note }}\n"

Checka in den och skicka upp den:

git add site.yml
git commit -m "First playbook"
git push origin main

Du ändrar playbooks på samma sätt: redigera, checka in och skicka upp. Semaphore hämtar den senaste versionen före varje körning.

8. Sätt upp projektet

I Semaphore väljer du New Project, ger det ett Project Name, till exempel Servers, kryssar i Allow alerts for this project och väljer Create. Ett projekt rymmer allt nedan. Dess meny till vänster har en sida för varje del.

Key Store > New Key: SSH-nyckeln som Semaphore loggar in med.

• Key Name: deploy. Type: SSH Key. Username (Optional): deploy.
• Private Key: klistra in hela utskriften av cat /root/semaphore-key, som du kör som root, från -----BEGIN till -----END OPENSSH PRIVATE KEY-----.

Välj Create. Semaphore krypterar nyckeln med access-key-encryption från steg 2 och visar den aldrig igen, inte ens för administratörer. Radera nu kopian på servern, som root: rm /root/semaphore-key.

Repositories > New Repository:

• Name: ops. URL or path: file:///repos/ops.git. Branch / Tag: main. Access Key: None.

För ett förråd på GitHub eller Forgejo använder du dess SSH-adress, till exempel git@github.com:example/ops.git, och en SSH-nyckel från Key Store som har läsrätt till det, till exempel en deploy-nyckel.

Inventory > New Inventory > Ansible Inventory, listan över servrar:

• Name: Servers. User Credentials: deploy. Type: Static.
• Själva listan:

[web]
host.containers.internal ansible_user=deploy ansible_python_interpreter=/usr/bin/python3

host.containers.internal är den här servern, sedd inifrån podden: där leder serverns egen publika adress tillbaka in i podden. Andra servrar får egna rader, med namn eller adress, till exempel web2.example.com ansible_user=deploy. Ansible behöver Python på varje server, vilket Debian har.

Variable Groups > New Group: värden som varje körning med den här gruppen får.

• Group Name: Production. Extra variables: {"note": "Managed by Semaphore"}.

Välj Create.

9. Kör en playbook

Task Templates > New template > Ansible Playbook knyter ihop allt:

• Name: Check servers. Path to playbook file: site.yml.
• Inventory: Servers. Repository: ops. Variable Groups: Production.
• Under Survey Variables väljer du Add variable: Name note, Title Note to write. Semaphore frågar efter den före varje körning, och svaret går före värdet från variabelgruppen.

Välj Create, öppna mallen och välj Run. Skriv en anteckning, till exempel Hello from Semaphore, och välj Run. Utskriften kommer rad för rad: Semaphore klonar förrådet, sedan ansluter Ansible och kör varje uppgift:

TASK [Print it] ****************************************************************
ok: [host.containers.internal] =>
    msg: 'web1: /dev/vda3        59G  4.7G   52G   9% /'

TASK [Write a note in the home directory] **************************************
changed: [host.containers.internal]

PLAY RECAP *********************************************************************
host.containers.internal   : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

På servern visar cat /home/deploy/semaphore-note.txt din anteckning. History listar varje körning, med vem som startade den, vilken version i Git den körde och hela utskriften.

Avbilden stänger av kontrollen av SSH-värdnycklar, så Semaphore ansluter till vilken server som helst som svarar på adressen i listan, utan att kontrollera att det är rätt server. Håll adresserna i listan till servrar och nätverk du litar på.

10. Kör den enligt schema

Schedule > New Schedule > Cron:

• Name: Weekday mornings. Template: Check servers.
• Cron: 0 6 * * 1-5, klockan 06.00 måndag till fredag.

Välj Create. Tiderna följer SEMAPHORE_SCHEDULE_TIMEZONE från steg 3: i vårt test kördes ett schema satt till 05.05 klockan 05.05 svensk tid. En schemalagd körning ställer inga frågor, så playbooken får värdena från variabelgruppen. Run once i samma meny kör en mall en gång, vid ett visst datum och klockslag.

11. Lägg till kollegor

Som administratör öppnar du Users i menyn längst ner till vänster och väljer New User: ett Name, Username, Email och Password. Låt Admin user vara avstängt: administratörer kan se och ändra varje projekt. Skicka lösenordet till personen på ett säkert sätt; Semaphore skickar inga inbjudningar.

I projektet väljer du sedan Team > New Team Member, och väljer User och en Role:

• Owner: allt, även att radera projektet.
• Manager: ändrar mallar, nycklar, serverlistor och teamet.
• Task Runner: kör mallarna, ändrar ingenting.
• Guest: läser mallar, körningar och deras utskrift, inget mer.

I vårt test kunde en gäst läsa utskriften av varje körning, men fick 403 Forbidden vid försök att starta en körning eller skapa en mall, och såg namnen på nycklarna men inte nycklarna. Egna roller är en Enterprise-funktion.

12. E-post och andra larm

Semaphore skickar en sorts e-post: ett larm när en körning misslyckas, till varje användare som har Send alerts ikryssat, i projekt med Allow alerts for this project. Den har ingen återställning av lösenord via e-post, så inget annat slutar fungera utan e-post.

För att skicka e-post via din e-postleverantör sparar du SMTP-lösenordet som semaphore:

printf %s 'the-smtp-password' | podman secret create semaphore-mail-password -

Lägg sedan till de här raderna i semaphore-app.container, med din egen server, ditt konto och din avsändaradress:

Environment=SEMAPHORE_EMAIL_ALERT=true SEMAPHORE_EMAIL_HOST=smtp.example.com SEMAPHORE_EMAIL_PORT=587 SEMAPHORE_EMAIL_SECURE=true
Environment=SEMAPHORE_EMAIL_USERNAME=ops@example.com SEMAPHORE_EMAIL_SENDER=ops@example.com
Secret=semaphore-mail-password,type=env,target=SEMAPHORE_EMAIL_PASSWORD

systemctl --user daemon-reload
systemctl --user restart semaphore-app

SEMAPHORE_EMAIL_SECURE=true gör att Semaphore loggar in med användarnamnet och lösenordet. På port 587 byter den till TLS med STARTTLS när servern erbjuder det. För port 465, som använder TLS från början, byter du port och lägger till SEMAPHORE_EMAIL_TLS=true.

Kryssa sedan i Send alerts för ditt konto under Edit Account. Test Alerts under projektets Settings skickar ett testlarm till alla som får larm. I vårt test, mot en testserver för e-post på samma server, skickade en misslyckad körning Task 'Broken' failed med en länk till körningen på https://ops.example.com. Vi har inte skickat via en riktig e-postleverantör.

Semaphore kan också skriva till Slack, Telegram, Microsoft Teams, Rocket.Chat, DingTalk och Gotify, både för lyckade och misslyckade körningar. Det ställs in med SEMAPHORE_SLACK_ALERT=true och SEMAPHORE_SLACK_URL, SEMAPHORE_TELEGRAM_ALERT, SEMAPHORE_TELEGRAM_CHAT och SEMAPHORE_TELEGRAM_TOKEN, och så vidare. Spara token som hemligheter som ovan. Suppress success notifications på en mall begränsar de kanalerna till misslyckade körningar. Vi har inte testat dem.

13. Starta en körning via API:t

Allt i webbgränssnittet går via Semaphores REST-API, som skript också kan använda. Öppna menyn med ditt namn, API Tokens > New Token, ge den ett Token Name och kopiera token. Den agerar som du, med alla dina rättigheter, så för ett skript gör du en egen användare med rollen Task Runner och en token för den.

Siffrorna i adressen till en malls sida, till exempel /project/1/templates/1, är projektets och mallens id. För att starta en körning, från valfri dator:

curl -s -X POST https://ops.example.com/api/project/1/tasks \
  -H 'Authorization: Bearer YOUR_TOKEN' -H 'Content-Type: application/json' \
  -d '{"template_id": 1, "environment": "{\"note\": \"Started from the API\"}"}'

Svaret innehåller körningens id och "status":"waiting". environment sätter frågevariablerna; utelämna det för att använda variabelgruppen. GET /api/project/1/tasks/ID visar status och /api/project/1/tasks/ID/output utskriften. Semaphores dokumentation beskriver resten av API:t.

14. Anslutningar utåt

Vi avlyssnade serverns DNS-uppslagningar och nya utgående anslutningar, över IPv4 och IPv6, medan Semaphore startade, medan användare loggade in och körde playbooks och medan ett schema kördes. Semaphore gjorde inga egna: ingen kontroll av uppdateringar och inga användningsdata. Webbgränssnittet laddar sina typsnitt och ikoner från Semaphore själv; länkar till Semaphores webbplats finns bredvid Pro-funktionerna och öppnas bara om någon klickar på dem.

Det den ansluter till är det du ger den: Git-förråden under Repositories, servrarna i dina serverlistor över SSH, din SMTP-server och dina larmtjänster. Om ett förråd har en requirements.yml installerar Semaphore de roller och samlingar som står där från Ansible Galaxy, galaxy.ansible.com, före varje körning; Skip Galaxy install på mallen stoppar det.

15. Säkerhetskopiera

Som semaphore:

umask 077
mkdir -p ~/backup
podman exec semaphore-db pg_dump -U semaphore -d semaphore > ~/backup/semaphore-db.sql
for s in access-key-encryption cookie-hash cookie-encryption; do
  podman secret inspect --showsecret --format '{{.SecretData}}' semaphore-$s > ~/backup/$s.txt
done
cp ~/.config/containers/systemd/semaphore* ~/backup/
tar -C ~ -cf ~/backup/repos.tar repos

Databasen innehåller projekten, användarna, nycklarna, serverlistorna, mallarna, schemana, token och utskriften av varje körning. Nycklarna går inte att använda utan access-key-encryption.txt, som loopen sparar tillsammans med cookie-nycklarna. Med Quadlet-filerna och Git-förråden är det hela Semaphore: filerna den har i /tmp/semaphore är kloner som den gör om. Dumpen körs medan Semaphore fortsätter att fungera. Kopiera ~/backup till en annan maskin, till exempel med restic, och förvara den säkert: tillsammans med nyckeln öppnar den varje SSH-nyckel i Semaphore.

För att återställa på en ny server, eller efter att ha tagit bort allt, gör du steg 1 och sedan, som semaphore, med säkerhetskopian i ~/backup:

openssl rand -hex 24 | tr -d '\n' | podman secret create semaphore-db-password -
for s in access-key-encryption cookie-hash cookie-encryption; do
  tr -d '\n' < ~/backup/$s.txt | podman secret create semaphore-$s -
done
tar -C ~ -xf ~/backup/repos.tar
mkdir -p ~/.config/containers/systemd
cp ~/backup/semaphore.pod ~/backup/semaphore-*.container ~/.config/containers/systemd/
systemctl --user daemon-reload
systemctl --user start semaphore-db
podman exec -i semaphore-db psql -q -U semaphore -d semaphore < ~/backup/semaphore-db.sql > /dev/null
systemctl --user start semaphore-pod
systemctl --user enable --now podman-auto-update.timer

Genom att bara starta databasen först läses säkerhetskopian in innan Semaphore sätter upp en tom databas. > /dev/null döljer de många rader som psql skriver ut för dumpen; fel visas ändå. Om du har satt upp e-post skapar du semaphore-mail-password igen före de två sista raderna. I vårt test hade den återställda Semaphore samma projekt, mallar, scheman, användare och token, det gamla lösenordet och API-token fungerade, och en playbook kördes med SSH-nyckeln från säkerhetskopian.

16. Uppdatera

Semaphores avbild är låst till en version. När en ny kommer läser du versionsinformationen på GitHub, gör en säkerhetskopia och byter sedan taggen i semaphore-app.container, till exempel från v2.19.16 till v2.19.17, och startar om:

systemctl --user daemon-reload
systemctl --user restart semaphore-app
podman image rm docker.io/semaphoreui/semaphore-community:v2.19.16

Semaphore uppdaterar sin databas när den startar. Vår uppdatering från 2.19.15 till 2.19.16 tog ungefär en minut, mest för att ladda ner den nya avbilden. Den sista raden tar bort den gamla, vilket frigör omkring 1,3 GB. podman auto-update håller PostgreSQL 18 uppdaterad av sig själv. Semaphore 2.20 testades fortfarande när vi skrev det här.

Felsökning

semaphore-app startar om hela tiden, och loggen säger pq: SSL is not enabled on the server. Raden SEMAPHORE_DB_OPTIONS saknas. Kontrollera med journalctl --user -u semaphore-app.

En körning misslyckas med detected dubious ownership in repository. Raden UserNS=keep-id i semaphore.pod saknas, eller så tillhör förrådet i ~/repos en annan användare än semaphore.

En körning misslyckas med UNREACHABLE och Connection refused för den här servern. Serverlistan använder serverns publika namn eller adress, som leder tillbaka in i podden. Använd host.containers.internal för den här servern.

UNREACHABLE med Permission denied (publickey). Den publika nyckeln finns inte i ~/.ssh/authorized_keys hos användaren i serverlistan, eller så har nyckeln i Key Store ett annat Username.

Sidan förblir tom, eller inloggningen fungerar men inget laddas. SEMAPHORE_WEB_ROOT stämmer inte med adressen i webbläsaren. Den måste vara hela https://-adressen som Caddy visar.

Inget e-postmeddelande kommer efter en misslyckad körning. Kontrollera att projektet har Allow alerts for this project och ditt konto Send alerts. Körningens utskrift slutar med Sent successfully email alert to eller felet från e-postservern.