# Docker Compose

Kör en komplett, kostnadsfri Status200-instans på en enda Linux-server med Docker Compose. Den här sidan tar dig från en ny server till en körande instans och tar sedan upp HTTPS, härdning för produktion, säkerhetskopior, uppdateringar och borttagning. Vill du i stället arbeta med Status200s egen kod, se [Lokal utveckling](/docs/installation/local-development).

:::cards
- [Installera Status200](#installera-oneuptime): Från en ny server till ditt första konto i sex steg.
- [Konfigurera HTTPS](#konfigurera-https): Låt Status200 hämta ett certifikat, eller sätt din egen proxy framför.
- [Checklista för produktion](#checklista-för-produktion): Vad som ska vara klart innan riktig trafik kommer.
- [Uppdatera Status200](#uppdatera-oneuptime): Byt till den senaste releasen.
:::

## Så fungerar det

Docker Compose kör varje del av Status200 som en container på din server. All trafik kommer in genom containern `ingress`, som skickar den vidare till `app`. Appen sparar sina data i PostgreSQL, ClickHouse och Valkey. En medföljande prob kör dina monitorers kontroller och rapporterar tillbaka genom ingressen.

```mermaid title="Installationen med Docker Compose"
flowchart TB
    Users["Användare och agenter"]
    Proxy["Din omvända<br/>proxy, valfri"]
    Targets["Webbplatser<br/>du övervakar"]
    subgraph Server["Din server"]
        Ingress["ingress"]
        App["app"]
        Probe["probe-1"]
        Runner["runner"]
        subgraph Data["Datalager"]
            direction LR
            PG[("postgres")]
            CH[("clickhouse")]
            VK[("valkey")]
        end
    end
    Users -->|HTTPS| Proxy
    Proxy -->|HTTP| Ingress
    Users -.->|"utan proxy"| Ingress
    Ingress --> App
    App --> PG
    App --> CH
    App --> VK
    Probe -->|resultat| Ingress
    Runner -->|jobb| Ingress
    Probe -->|kontroller| Targets
    Data ~~~ Probe
    Data ~~~ Runner
```

| Tjänst | Image | Vad den gör |
| --- | --- | --- |
| `ingress` | `status200/nginx` | Tar emot all trafik på port 80 och 443 och skickar den vidare till appen. Levererar HTTPS när Status200 hanterar certifikatet. |
| `app` | `status200/app` | Dashboarden, API:t, statussidor, inläsning av telemetri och bakgrundsarbetarna. |
| `probe-1` | `status200/probe` | En global prob som kör dina monitorers kontroller. Den använder värdens nätverk. |
| `runner` | `status200/runner` | Instansens Runner, som kör AI-kodkorrigeringar. Den använder värdens nätverk. |
| `postgres` | `postgres:15` | Konfiguration och tillstånd: monitorer, incidenter, användare. Lagras i volymen `postgres`. |
| `clickhouse` | `clickhouse/clickhouse-server:26.7` | Telemetri: loggar, mätvärden, traces och undantag. Lagras i volymen `clickhouse`. |
| `valkey` | `valkey/valkey:9.1-alpine` | Cache och köer. Den sparar ingenting på disk. |

> [!NOTE]
> Tjänsten `valkey` kör [Valkey](https://valkey.io), den BSD-licensierade forken av Redis 7.2, konfigurerad via inställningarna `VALKEY_*` i `config.env`. Alla servrar som talar Redis-protokollet fungerar — peka `VALKEY_HOST` mot en hanterad Redis om du föredrar det. Fram till 13.0.0 hette de här inställningarna `REDIS_*`; de gamla namnen läses fortfarande, containern svarar fortfarande på värdnamnet `redis`, och `npm run update` skriver inte om dem, så en äldre `config.env` behöver inga ändringar.

För produktion i stor skala, eller när du behöver hög tillgänglighet, använder du i stället [Helm-charten](https://artifacthub.io/packages/helm/status200/status200) på Kubernetes: Docker Compose kör en kopia av varje tjänst på en enda server.

## Krav

Välj serverns storlek efter vad du ska köra på den. Det är telemetrin (loggar, mätvärden, traces) som avgör minne och disk; se [Dimensionering och kapacitetsplanering](/docs/installation/sizing) när du känner till dina volymer.

| | Rekommenderat | Minimum för ett homelab |
| --- | --- | --- |
| **Minne** | 16 GB | 8 GB |
| **CPU** | 8 kärnor | 4 kärnor |
| **Disk** | 400 GB | 20 GB |
| **System** | Ubuntu 22.04, eller en annan Linux baserad på Debian, Ubuntu eller RHEL | Samma |
| **Arkitektur** | x86-64 (`amd64`) eller ARM (`arm64`) | Samma |

Minimum för ett homelab passar för personligt och experimentellt bruk — en del kör Status200 på en Raspberry Pi.

Du behöver också:

- **Docker** med tillägget **Docker Compose v2** (kommandot `docker compose`).
- **Git**, för att hämta Status200.
- **Node.js och npm**, som kör skripten `npm start` och `npm run update` som omsluter Docker Compose.
- **Portarna 80 och 443** lediga på servern. Tabellen nedan listar varje port som Status200 använder på värden.

| Värdport | Används av | Inställning | Vad den är till för |
| --- | --- | --- | --- |
| 80 | `ingress` | `ONEUPTIME_HTTP_PORT` | Dashboarden, API:t, inläsning av telemetri och validering hos Let's Encrypt. |
| 443 | `ingress` | `STATUS_PAGE_HTTPS_PORT` | HTTPS för din instans när Status200 hanterar certifikatet, och för statussidor och dashboards på egna domäner. |
| 5400 | `postgres` | Anges i `docker-compose.yml` | Låter `npm run backup` och `restore.sh` nå PostgreSQL från själva servern. Den är bara publicerad på `127.0.0.1`. |
| 3874 | `probe-1` | `GLOBAL_PROBE_1_PORT` | Probens egen server. Inget utanför servern behöver den. |
| 3876 | `runner` | `ONEUPTIME_RUNNER_PORT` | Runnerns egen server. Inget utanför servern behöver den. |

Det finns också en [videogenomgång](https://youtu.be/j1SWmMW2oL4) av installationen.

## Installera Status200

:::steps
### Klona release-grenen

Grenen `release` innehåller filerna för den senaste releasen.

```bash
git clone --depth 1 --single-branch --branch release https://git.wilix.dev/status200/status200.git
cd oneuptime
```

### Skapa config.env

Alla Status200s inställningar finns i `config.env`. Utgå från exemplet:

```bash
cp config.example.env config.env
```

### Ange värdnamnet

Öppna `config.env` och sätt `HOST` till det domännamn eller den IP-adress som folk ska använda för att nå Status200, utan `http://`. Behåll `localhost` bara för att prova Status200 på din egen dator.

```ini title="config.env"
HOST=status200.example.com
```

### Generera slumpmässiga hemligheter

Exempelfilen innehåller platshållarhemligheter som är offentliga på GitHub. Ersätt var och en med ett eget slumpmässigt värde:

```bash
while grep -q "please-change-this-to-random-value" config.env; do
  sed -i "0,/please-change-this-to-random-value/{s/please-change-this-to-random-value/$(openssl rand -hex 32)/}" config.env
done
grep -c "please-change-this" config.env
```

Det sista kommandot skriver ut `0`: Ingen platshållare är kvar. Loopen använder GNU `sed`, som alla Linux-servrar har. Det här är inställningarna den fyller i:

| Inställning | Vad den skyddar |
| --- | --- |
| `ONEUPTIME_SECRET` | Anrop mellan Status200s egna tjänster. |
| `ENCRYPTION_SECRET` | Hemligheterna som Status200 lagrar, som integrationstokens och SMTP-lösenord, och de inloggningstokens den utfärdar. |
| `DATABASE_PASSWORD`, `CLICKHOUSE_PASSWORD`, `VALKEY_PASSWORD` | De tre datalagren. |
| `REGISTER_PROBE_KEY` | Registrering av prober hos din instans. |
| `GLOBAL_PROBE_1_KEY`, `GLOBAL_PROBE_2_KEY` | De globala prober som Docker Compose kan köra (`probe-1` körs som standard). |
| `STATUS200_RUNNER_KEY` | Den medföljande Runnern. |
| `GLOBAL_RUNNER_KEY` | Den medföljande globala Runnern, som kör alla projekts JavaScript-steg. |

> [!IMPORTANT]
> Ange hemligheterna före första starten och behåll dem sedan. PostgreSQL tar bara sitt lösenord när den skapar sin databas, och om du ändrar `ENCRYPTION_SECRET` senare blir varje värde som krypterats med det gamla oläsligt. Är `DATABASE_PASSWORD` fortfarande platshållaren vid första starten ger `npm start` den ett slumpmässigt värde innan PostgreSQL skapar sin databas.

### Starta Status200

:::tabs
@tab npm
```bash
npm start
```
@tab Docker CLI
```bash
(export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)
```
:::

Första starten tar flera minuter: Docker laddar ned imagerna och Status200 skapar sina databaser. `npm start` väntar tills varje del svarar och avslutas med **Status200 is up!**

### Skapa det första kontot

Öppna `http://` följt av din `HOST` (till exempel `http://localhost`) och registrera dig. Det första kontot på en ny instans blir dess huvudadministratör, som kan öppna Admin Dashboard på `/admin`.

Alla som kan nå sidan kan registrera sig efter dig. För att förhindra det öppnar du Admin Dashboard, går till **Inställningar > Autentisering** och stänger av **Tillåt registrering**. Personer som du bjuder in till ett projekt kan fortfarande skapa sina konton.
:::

## Konfigurera HTTPS

Status200 levererar vanlig HTTP tills du väljer ett av två sätt att lägga till HTTPS:

| | Låt Status200 hämta ett certifikat | Använd din egen omvända proxy |
| --- | --- | --- |
| **TLS avslutas i** | Status200s `ingress`, med ett kostnadsfritt certifikat från Let's Encrypt som den förnyar själv | Din proxy: Caddy, Nginx eller en lastbalanserare |
| **Du behöver** | Ett offentligt domännamn som pekar på servern, och portarna 80 och 443 nåbara från internet | En proxy och ett certifikat för din domän |
| **Inställningar** | `PROVISION_SSL=true`, `HTTP_PROTOCOL=https` | `PROVISION_SSL=false`, `HTTP_PROTOCOL=https`, `TRUSTED_PROXY_HOPS=2` |
| **Statussidor på egna domäner** | Fungerar utan extra konfiguration | Din proxy måste också betjäna de domänerna |

Om du lägger statussidor eller dashboards på egna domäner är det enklast att låta Status200 hantera TLS: Ingressen beställer och levererar själv certifikaten för de domänerna.

Med `HTTP_PROTOCOL=https` bygger Status200 HTTPS-länkar, håller inloggningscookies på HTTPS och ber webbläsare att bara nå din `HOST` över HTTPS. En webbläsare håller sig till det i ett år, på alla portar för det namnet, så om `HOST` någon gång måste svara över vanlig HTTP igen sätter du `HSTS_MAX_AGE_SECONDS=0` i `config.env` en tid innan: Webbläsare glömmer regeln vid sitt nästa besök.

### Låt Status200 hämta ett certifikat

:::steps
#### Peka din domän mot servern

Skapa en DNS-post `A` (eller `AAAA` för IPv6) för din domän, med serverns offentliga IP-adress som värde. Med en `AAAA`-post slår du också på IPv6 för Status200: se [Besökarnas adresser](#besökarnas-adresser).

#### Slå på hämtning av certifikat

Ange de här värdena i `config.env`:

```ini title="config.env"
HOST=status200.example.com
PROVISION_SSL=true
HTTP_PROTOCOL=https
```

`HOST` måste vara ett domännamn: Status200 kan inte få ett certifikat för en IP-adress eller för `localhost`.

#### Starta om med de nya inställningarna

```bash
npm start
```

#### Öppna din instans över HTTPS

Öppna `https://status200.example.com`. Status200 beställer certifikatet när den startar, kontrollerar det sedan varje timme och förnyar det när det är mindre än 30 dagar kvar. Tills det första certifikatet kommer, oftast inom några minuter, levererar ingressen ett tillfälligt självsignerat certifikat och webbläsaren varnar dig.
:::

### Använd din egen omvända proxy

De här stegen kör proxyn på samma server som Status200. Om din proxy körs på en annan maskin hoppar du över det första steget, pekar proxyn mot port 80 på den här servern och låter med molnleverantörens brandvägg bara proxyn nå portarna 80 och 443: en besökare som når Status200 förbi proxyn kan välja den adress som Status200 räknar besökaren efter.

:::steps
#### Flytta ingressen från portarna 80 och 443

Proxyn behöver portarna 80 och 443, så flytta ingressen till andra portar, publicerade bara på serverns loopback-adress `127.0.0.1`, så att besökare bara når Status200 genom din proxy. Proben och Runnern använder värdens nätverk och når Status200 via `http://localhost`, så de flyttar med:

```ini title="config.env"
ONEUPTIME_HTTP_PORT=127.0.0.1:8080
STATUS_PAGE_HTTPS_PORT=127.0.0.1:8443
GLOBAL_PROBE_1_STATUS200_URL=http://localhost:8080
ONEUPTIME_RUNNER_STATUS200_URL=http://localhost:8080
```

#### Berätta för Status200 att den står bakom en proxy

```ini title="config.env"
HOST=status200.example.com
HTTP_PROTOCOL=https
PROVISION_SSL=false
TRUSTED_PROXY_HOPS=2
```

`HTTP_PROTOCOL=https` gör att länkarna som Status200 bygger använder HTTPS. `TRUSTED_PROXY_HOPS=2` räknar din proxy och Status200s ingress, så att Status200 läser besökarens riktiga adress för IP-tillåtelselistor och hastighetsbegränsningar. Lägg till en för varje ytterligare proxy som lägger till i `X-Forwarded-For`, som ett CDN eller en lastbalanserare.

#### Starta om Status200 på de nya portarna

```bash
(export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)
bash Tests/Scripts/status-check.sh localhost:8080
```

`npm start` kontrollerar `http://localhost` på port 80, där din proxy kommer att ligga, så kontrollera den nya porten själv. Skriptet avslutas med **Status200 is up!**

#### Konfigurera proxyn

:::tabs
@tab Caddy
```text title="Caddyfile"
status200.example.com {
	reverse_proxy localhost:8080
}
```
Caddy hämtar och förnyar certifikatet själv, omdirigerar HTTP till HTTPS och släpper igenom WebSocket-anslutningar. Läs in Caddy igen när du har ändrat filen, till exempel med `sudo systemctl reload caddy`.
@tab Nginx
```nginx title="/etc/nginx/conf.d/status200.conf"
map $http_upgrade $status200_connection_upgrade {
    default upgrade;
    ""      close;
}

server {
    listen 80;
    server_name status200.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name status200.example.com;

    ssl_certificate     /etc/letsencrypt/live/status200.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/status200.example.com/privkey.pem;

    # The limits Status200's own ingress uses.
    client_max_body_size 50M;
    proxy_read_timeout 300s;
    proxy_send_timeout 300s;

    proxy_http_version 1.1;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $status200_connection_upgrade;

    location / {
        proxy_pass http://127.0.0.1:8080;
    }

    # MCP clients keep a stream open.
    location /mcp {
        proxy_pass http://127.0.0.1:8080;
        proxy_buffering off;
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}
```
Certifikatsökvägarna är där Certbot lägger ett certifikat från Let's Encrypt; använd sökvägarna till ditt eget certifikat om det kommer från något annat håll. Kontrollera filen och läs in Nginx igen med `sudo nginx -t && sudo systemctl reload nginx`.
:::

Båda skickar `X-Forwarded-Proto`, som talar om för Status200 att en besökare kom över HTTPS. Alla andra proxyer måste också skicka den, annars hålls inte inloggningscookies för statussidor och dashboards på dina egna domäner på HTTPS.

#### Öppna din instans genom proxyn

Öppna `https://status200.example.com`. Du bör se Status200s inloggningssida, levererad med din proxys certifikat.
:::

> [!NOTE]
> Bakom din egen proxy skickar du telemetri över OTLP/HTTP (`/otlp`). OTLP över gRPC når bara Status200 när dess egen ingress avslutar TLS (`PROVISION_SSL=true`).

## Besökarnas adresser

Status200 räknar varje besökare efter adressen som besökaren ansluter från: inloggningsgränserna, de andra gränserna per adress och IP-tillåtelselistorna för statussidor och dashboards läser den alla. Två uppsättningar behöver en inställning för att den adressen ska vara besökarens egen:

| Uppsättning | Inställning |
| --- | --- |
| Folk når Status200 över IPv6, till exempel genom en `AAAA`-post | IPv6 på Status200s nätverk, i `docker-compose.override.yml` |
| Din egen omvända proxy står framför Status200 | `TRUSTED_PROXY_HOPS=2`, med ingressen publicerad på `127.0.0.1` (se [Använd din egen omvända proxy](#använd-din-egen-omvända-proxy)) |

Utan IPv6 på Status200s nätverk lämnar Docker vidare varje besökare som kommer över IPv6 till Status200 från en egen adress, och Status200 räknar dem alla som en besökare: en persons misslyckade inloggningar kan låsa ute de andra. Att slå på IPv6 kräver Docker Engine 27 eller senare (`docker version` visar din).

:::steps
### Slå på IPv6

Skapa `docker-compose.override.yml` bredvid `docker-compose.yml`, eller lägg till detta i den du har; `npm start` och `npm run update` läser den:

```yaml title="docker-compose.override.yml"
networks:
  oneuptime:
    enable_ipv6: true
```

### Starta om Status200

```bash
npm stop
npm start
```

Status200 stannar och startar igen med IPv6 på sitt nätverk. Dina data behålls. Docker kan inte ta bort ett nätverk som en egen container fortfarande är ansluten till, till exempel en omvänd proxy: koppla först bort den från Status200s nätverk och anslut den igen efteråt. Stannar `npm start` med `has active endpoints` kopplar du bort den och kör `npm stop` och `npm start` igen.

### Kontrollera nätverket

```bash
docker network ls --quiet --filter name=_oneuptime | xargs docker network inspect | grep EnableIPv6
```

Det skriver ut `"EnableIPv6": true,`.
:::

När flera personer loggar in från samma privata nätverksadress säger sidan **Status200-hälsa** i Admin Dashboard det, med inställningen som ändrar det.

## Checklista för produktion

Docker Compose kör en kopia av varje tjänst på en enda server, vilket passar små team och homelabs. Gå igenom den här listan innan du förlitar dig på det.

| Område | Vad du gör |
| --- | --- |
| **Hemligheter** | Inget värde i `config.env` är fortfarande en platshållare `please-change-this-to-random-value`. Se [Generera slumpmässiga hemligheter](#generera-slumpmässiga-hemligheter), och [Byt databasens lösenord](#byt-databasens-lösenord) för en installation som startade med platshållaren i `DATABASE_PASSWORD`. |
| **HTTPS** | Folk når Status200 över HTTPS och `HTTP_PROTOCOL=https` är angivet. Se [Konfigurera HTTPS](#konfigurera-https). |
| **Registreringar** | När ditt team har konton stänger du av **Tillåt registrering** under **Inställningar > Autentisering** i Admin Dashboard. |
| **Brandvägg** | Bara portarna 80 och 443 (och SSH) är öppna mot internet. Status200 publicerar PostgreSQLs port 5400 bara på `127.0.0.1`. Stäng varje annan port du publicerar med din molnleverantörs brandvägg: `ufw`-regler gäller inte portar som Docker publicerar. |
| **Besökarnas adresser** | Sidan **Status200-hälsa** i Admin Dashboard säger inte att flera personer loggar in från samma adress. Se [Besökarnas adresser](#besökarnas-adresser). |
| **Säkerhetskopior** | PostgreSQL säkerhetskopieras varje dag och kopiorna lämnar servern. Se [Säkerhetskopiera och återställ](#säkerhetskopiera-och-återställ). |
| **E-post** | En e-postserver är konfigurerad under **Inställningar > Notifieringar > E-post** i Admin Dashboard, så att Status200 kan skicka inbjudningar och aviseringar. Se [SMTP](/docs/emails/smtp). |
| **Disk** | Det lediga utrymmet övervakas. ClickHouse växer med den telemetri du behåller (se [Dimensionering och kapacitetsplanering](/docs/installation/sizing)); varje containers logg är begränsad till 1000 MB. |
| **Uppdateringar** | Status200 uppdateras minst en gång i veckan. Nya releaser kommer ofta. Se [Uppdatera Status200](#uppdatera-oneuptime). |
| **Hög tillgänglighet** | Om du behöver det byter du till [Helm-charten](https://artifacthub.io/packages/helm/status200/status200) på Kubernetes. |

### Byt databasens lösenord

PostgreSQL behåller lösenordet den skapades med, så om du bara ändrar `DATABASE_PASSWORD` i `config.env` stänger du ute Status200 från dess databas. För att ge en installation som startade med platshållaren ett eget lösenord ändrar du det i PostgreSQL och i `config.env` samtidigt och startar sedan Status200 igen:

```bash
NEW_PASSWORD=$(openssl rand -hex 32) &&
  (export $(grep -v '^#' config.env | xargs) && docker compose exec -T postgres psql -U "$DATABASE_USERNAME" -d "$DATABASE_NAME" -c "ALTER USER \"$DATABASE_USERNAME\" PASSWORD '$NEW_PASSWORD'") &&
  sed -i "s/^DATABASE_PASSWORD=.*/DATABASE_PASSWORD=$NEW_PASSWORD/" config.env
npm start
```

Om du har angett `DATABASE_BACKUP_PASSWORD` och `DATABASE_RESTORE_PASSWORD`, ge dem också det nya värdet.

## Säkerhetskopiera och återställ

PostgreSQL innehåller allt du konfigurerar: monitorer, incidenter, statussidor, användare. `npm run backup` dumpar det till en fil i mappen `Backups`.

:::steps
### Ge säkerhetskopieringsskriptet databaslösenordet

Sätt `DATABASE_BACKUP_PASSWORD` i `config.env` till värdet av `DATABASE_PASSWORD`. Skriptet läser `config.env` som ren text, så det medföljande `${DATABASE_PASSWORD}` fylls aldrig i.

### Kör säkerhetskopieringen

```bash
npm run backup
```

Det frågar efter ditt sudo-lösenord och skriver `Backups/db-<day of the month>.backup`, så att dagliga säkerhetskopior ersätter dem från en månad tidigare. Kör det minst en gång om dagen.

### Kopiera säkerhetskopiorna från servern

En säkerhetskopia på samma disk som databasen överlever inte att den disken går förlorad.
:::

Bara servern själv når PostgreSQL: den svarar på port 5400 på `127.0.0.1`. För att säkerhetskopiera den från en annan maskin öppnar du en SSH-tunnel från den maskinen och ansluter sedan till dess egen port 5400:

```bash
ssh -N -L 5400:127.0.0.1:5400 you@status200.example.com
```

:::details Publicera PostgreSQL på en adress i ett privat nätverk
Om ett verktyg i ditt privata nätverk måste nå PostgreSQL utan tunnel, publicera den även på serverns adress i det nätverket, på en egen port. Skapa `docker-compose.override.yml` bredvid `docker-compose.yml`; `npm start` och `npm run update` läser den:

```yaml title="docker-compose.override.yml"
services:
  postgres:
    ports:
      - "10.0.0.5:5401:5432"
```

Använd serverns egen privata adress i stället för `10.0.0.5`, aldrig en offentlig, och ge först PostgreSQL ett eget lösenord (se [Byt databasens lösenord](#byt-databasens-lösenord)). Kör sedan `npm start`, så svarar PostgreSQL även på port 5401 på den adressen.
:::

ClickHouse håller din telemetri i Docker-volymen `status200_clickhouse`, och inget skript säkerhetskopierar den. Om du behöver behålla den telemetrin säkerhetskopierar du volymen med ett ClickHouse-verktyg som [clickhouse-backup](https://github.com/Altinity/clickhouse-backup), eller kopierar den medan Status200 är stoppat.

För att återställa PostgreSQL anger du värdena `DATABASE_RESTORE_*` i `config.env`: `DATABASE_RESTORE_PASSWORD` till värdet av `DATABASE_PASSWORD`, som för säkerhetskopior, och `DATABASE_RESTORE_FILENAME` till den säkerhetskopia som ska återställas, till exempel `db-31.backup`. Kör sedan `bash restore.sh`. Databasen som det återställer till måste redan finnas; i en körande installation gör den det.

> [!CAUTION]
> `restore.sh` tar bort varje objekt från säkerhetskopian ur måldatabasen innan det skapas på nytt. Det frågar innan det börjar; kontrollera databasnamnet som det visar.

## Uppdatera Status200

Säkerhetskopiera först och kör sedan:

```bash
git checkout release
git pull
npm run update
```

`npm run update` frågar efter ditt sudo-lösenord, lägger till nya inställningar från `config.example.env` i din `config.env` (dina egna värden finns kvar), hämtar de nya imagerna och startar om Status200. Precis som `npm start` avslutas det med **Status200 is up!**

Att byta till en ny huvudversion (från 13 till 14, till exempel) kan kräva mer: läs [Uppgradera Status200](/docs/installation/upgrading) innan du börjar.

`APP_TAG=release` i `config.env` hämtar alltid den senaste releasen av Community Edition. För att stanna på en version sätter du `APP_TAG` till dess nummer, till exempel `14.0.22`. För Enterprise Edition är taggarna `enterprise-release` och `enterprise-14.0.22`.

## Avinstallera Status200

Stoppa Status200 och ta bort dess containrar och nätverk:

```bash
npm run down
```

Dina data finns kvar i volymerna `status200_postgres` och `status200_clickhouse`, och mappen `oneuptime` behåller `config.env` och dina säkerhetskopior. För att ta bort även data:

```bash
(export $(grep -v '^#' config.env | xargs) && docker compose down --volumes --remove-orphans)
```

Ta sedan bort mappen `oneuptime`.

> [!CAUTION]
> `--volumes` tar bort varje monitor, incident, användare och all telemetri för gott. Säkerhetskopiera först om du kan komma att behöva något av det.

## Felsökning

:::details Docker säger "permission denied" när du kör npm start
Din användare når inte Docker-daemonen. Lägg till den i gruppen `docker` och logga sedan ut och in igen:

```bash
sudo usermod -aG docker $USER
```
:::

:::details Ingressen kan inte starta eftersom port 80 eller 443 används
Ett annat program på servern, ofta en webbserver, håller porten. Stoppa det, eller flytta ingressen till andra portar och sätt programmet framför Status200 enligt [Använd din egen omvända proxy](#använd-din-egen-omvända-proxy).
:::

:::details npm start avslutas med "Maximum retries reached"
Kontrollen som avslutar `npm start` gav upp innan Status200 svarade. Första starten kan ta längre tid än kontrollen väntar, medan imagerna laddas ned och databaserna skapas. Se vad som körs och läs loggarna:

```bash
npm run ps
npm run logs
```

När varje container körs kör du kontrollen igen med `npm run status-check`. Om du flyttade ingressen från port 80 kontrollerar du i stället dess nya port: `bash Tests/Scripts/status-check.sh localhost:8080`.
:::

:::details Vissa sidor läses in, men liveuppdateringar eller uppladdningar misslyckas
Öppna Status200 på adressen i `HOST`. Ingressen dirigerar begäranden efter värdnamn: bara `HOST` och `localhost` når hela applikationen, och alla andra namn, som serverns IP-adress, behandlas som en statussidas domän. Sätt `HOST` till det namn folk använder och kör sedan `npm start`.
:::

:::details Registrering eller inloggning misslyckas med "Page not found"
Registreringssidan läses in, men registreringen misslyckas med `Page not found - /identity/signup` och inloggningen med `Page not found - /identity/login`. Begäran nådde Status200 under ett annat värdnamn än `HOST`, så ingressen dirigerade den som en statussidas egen domän, där Status200s egen registrering och inloggning inte finns. Kontrollera båda:

- `HOST` är adressen folk öppnar, med porten om de använder en, som `status200.example.com:8080`. Kör `npm start` när du har ändrat den.
- En proxy framför Status200 skickar vidare värdnamnet som webbläsaren bad om. Caddy gör det som standard, Nginx med `proxy_set_header Host $host;` som i [Använd din egen omvända proxy](#använd-din-egen-omvända-proxy), och Apache med `ProxyPreserveHost On`.
:::

:::details Webbläsaren varnar för certifikatet efter att du har satt PROVISION_SSL
Tills Let's Encrypt utfärdar certifikatet levererar ingressen ett tillfälligt självsignerat certifikat. Om varningen ligger kvar i mer än några minuter kontrollerar du att:

- `HOST` är ett domännamn, inte en IP-adress och inte `localhost`.
- Domänens DNS-post pekar mot den här servern.
- Port 80 kan nås från internet, så att Let's Encrypt kan validera domänen.

När en beställning misslyckas loggar appen ett fel som börjar med `CoreSSL:EnsurePrimaryHostCertificate`, följt av orsaken:

```bash
(export $(grep -v '^#' config.env | xargs) && docker compose logs app) | grep -A 5 CoreSSL
```
:::

:::details Den medföljande proben visar Frånkopplad efter att du har flyttat ingressens port
Admin Dashboard listar proben under **Inställningar > Övervakning > Globala prober**. Den når Status200 på `GLOBAL_PROBE_1_STATUS200_URL`, som är `http://localhost` (port 80) som standard. Sätt den till ingressens nya port, till exempel `http://localhost:8080`, sätt `ONEUPTIME_RUNNER_STATUS200_URL` på samma sätt och starta om Status200.
:::

## Nästa steg

:::cards
- [Uppgradera Status200](/docs/installation/upgrading): Vad varje huvudversion kräver av dig.
- [Dimensionering och kapacitetsplanering](/docs/installation/sizing): Planera minne och disk för din telemetri.
- [Egenvärdad arkitektur](/docs/self-hosted/architecture): Hur komponenterna hänger ihop.
- [Enterprise Edition](/docs/self-hosted/enterprise): Vad Enterprise-imagen lägger till, och dess licens.
:::