# Docker Compose

Kjør en komplett, gratis Status200-instans på én Linux-server med Docker Compose. Denne siden tar deg fra en ny server til en kjørende instans, og dekker deretter HTTPS, herding for produksjon, sikkerhetskopier, oppdateringer og fjerning. Vil du heller jobbe med Status200s egen kode, se [Lokal utvikling](/docs/installation/local-development).

:::cards
- [Installer Status200](#installer-oneuptime): Fra en ny server til din første konto i seks steg.
- [Sett opp HTTPS](#sett-opp-https): La Status200 hente et sertifikat, eller sett din egen proxy foran.
- [Sjekkliste for produksjon](#sjekkliste-for-produksjon): Hva som må være på plass før ekte trafikk kommer.
- [Oppdater Status200](#oppdater-oneuptime): Gå over til den nyeste releasen.
:::

## Slik fungerer det

Docker Compose kjører hver del av Status200 som en container på serveren din. All trafikk kommer inn gjennom containeren `ingress`, som sender den videre til `app`. Appen lagrer dataene sine i PostgreSQL, ClickHouse og Valkey. En medfølgende probe kjører monitorenes sjekker og rapporterer tilbake gjennom ingressen.

```mermaid title="Installasjonen med Docker Compose"
flowchart TB
    Users["Brukere og agenter"]
    Proxy["Din reverse<br/>proxy, valgfri"]
    Targets["Nettsteder<br/>du overvåker"]
    subgraph Server["Serveren din"]
        Ingress["ingress"]
        App["app"]
        Probe["probe-1"]
        Runner["runner"]
        subgraph Data["Datalagre"]
            direction LR
            PG[("postgres")]
            CH[("clickhouse")]
            VK[("valkey")]
        end
    end
    Users -->|HTTPS| Proxy
    Proxy -->|HTTP| Ingress
    Users -.->|"uten proxy"| Ingress
    Ingress --> App
    App --> PG
    App --> CH
    App --> VK
    Probe -->|resultater| Ingress
    Runner -->|jobber| Ingress
    Probe -->|sjekker| Targets
    Data ~~~ Probe
    Data ~~~ Runner
```

| Tjeneste | Image | Hva den gjør |
| --- | --- | --- |
| `ingress` | `status200/nginx` | Tar imot all trafikk på port 80 og 443 og sender den videre til appen. Leverer HTTPS når Status200 administrerer sertifikatet. |
| `app` | `status200/app` | Dashbordet, API-et, statussider, innhenting av telemetri og bakgrunnsarbeiderne. |
| `probe-1` | `status200/probe` | En global probe som kjører monitorenes sjekker. Den bruker vertens nettverk. |
| `runner` | `status200/runner` | Instansens Runner, som kjører AI-kodeforbedringer. Den bruker vertens nettverk. |
| `postgres` | `postgres:15` | Konfigurasjon og tilstand: monitorer, hendelser, brukere. Lagret i volumet `postgres`. |
| `clickhouse` | `clickhouse/clickhouse-server:26.7` | Telemetri: logger, metrikker, traces og unntak. Lagret i volumet `clickhouse`. |
| `valkey` | `valkey/valkey:9.1-alpine` | Hurtigbuffer og køer. Den lagrer ingenting på disk. |

> [!NOTE]
> Tjenesten `valkey` kjører [Valkey](https://valkey.io), den BSD-lisensierte forken av Redis 7.2, konfigurert gjennom innstillingene `VALKEY_*` i `config.env`. Enhver server som snakker Redis-protokollen fungerer — pek `VALKEY_HOST` mot en administrert Redis hvis du foretrekker det. Fram til 13.0.0 het disse innstillingene `REDIS_*`; de gamle navnene leses fortsatt, containeren svarer fortsatt på vertsnavnet `redis`, og `npm run update` skriver dem ikke om, så en eldre `config.env` trenger ingen endringer.

For produksjon i stor skala, eller når du trenger høy tilgjengelighet, bruk i stedet [Helm-chartet](https://artifacthub.io/packages/helm/status200/status200) på Kubernetes: Docker Compose kjører én kopi av hver tjeneste på én server.

## Krav

Velg størrelsen på serveren etter hva du skal kjøre på den. Det er telemetrien (logger, metrikker, traces) som bestemmer minne og disk; se [Dimensjonering og kapasitetsplanlegging](/docs/installation/sizing) når du kjenner volumene dine.

| | Anbefalt | Minimum for et homelab |
| --- | --- | --- |
| **Minne** | 16 GB | 8 GB |
| **CPU** | 8 kjerner | 4 kjerner |
| **Disk** | 400 GB | 20 GB |
| **System** | Ubuntu 22.04, eller et annet Linux basert på Debian, Ubuntu eller RHEL | Det samme |
| **Arkitektur** | x86-64 (`amd64`) eller ARM (`arm64`) | Det samme |

Minimum for et homelab passer for personlig og eksperimentell bruk — noen kjører Status200 på en Raspberry Pi.

Du trenger også:

- **Docker** med tillegget **Docker Compose v2** (kommandoen `docker compose`).
- **Git**, for å hente Status200.
- **Node.js og npm**, som kjører skriptene `npm start` og `npm run update` som pakker inn Docker Compose.
- **Port 80 og 443** ledige på serveren. Tabellen nedenfor viser hver port Status200 bruker på verten.

| Vertsport | Brukes av | Innstilling | Hva den er til |
| --- | --- | --- | --- |
| 80 | `ingress` | `ONEUPTIME_HTTP_PORT` | Dashbordet, API-et, innhenting av telemetri og validering hos Let's Encrypt. |
| 443 | `ingress` | `STATUS_PAGE_HTTPS_PORT` | HTTPS for instansen din når Status200 administrerer sertifikatet, og for statussider og dashbord på egne domener. |
| 5400 | `postgres` | Satt i `docker-compose.yml` | Lar `npm run backup` og `restore.sh` nå PostgreSQL fra selve serveren. Den er bare publisert på `127.0.0.1`. |
| 3874 | `probe-1` | `GLOBAL_PROBE_1_PORT` | Probens egen server. Ingenting utenfor serveren trenger den. |
| 3876 | `runner` | `ONEUPTIME_RUNNER_PORT` | Runnerens egen server. Ingenting utenfor serveren trenger den. |

Det finnes også en [videogjennomgang](https://youtu.be/j1SWmMW2oL4) av installasjonen.

## Installer Status200

:::steps
### Klon release-grenen

Grenen `release` inneholder filene for den nyeste releasen.

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

### Opprett config.env

Alle innstillingene til Status200 ligger i `config.env`. Start med eksemplet:

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

### Angi vertsnavnet

Åpne `config.env` og sett `HOST` til domenenavnet eller IP-adressen folk skal bruke for å nå Status200, uten `http://`. Behold `localhost` bare for å prøve Status200 på din egen datamaskin.

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

### Generer tilfeldige hemmeligheter

Eksempelfilen har plassholderhemmeligheter som er offentlige på GitHub. Erstatt hver av dem med sin egen tilfeldige verdi:

```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
```

Den siste kommandoen skriver ut `0`: Det er ingen plassholder igjen. Løkken bruker GNU `sed`, som alle Linux-servere har. Dette er innstillingene den fyller ut:

| Innstilling | Hva den beskytter |
| --- | --- |
| `ONEUPTIME_SECRET` | Kall mellom Status200s egne tjenester. |
| `ENCRYPTION_SECRET` | Hemmelighetene Status200 lagrer, som integrasjonstokener og SMTP-passord, og påloggingstokenene den utsteder. |
| `DATABASE_PASSWORD`, `CLICKHOUSE_PASSWORD`, `VALKEY_PASSWORD` | De tre datalagrene. |
| `REGISTER_PROBE_KEY` | Registrering av prober hos instansen din. |
| `GLOBAL_PROBE_1_KEY`, `GLOBAL_PROBE_2_KEY` | De globale probene Docker Compose kan kjøre (`probe-1` kjører som standard). |
| `STATUS200_RUNNER_KEY` | Den medfølgende Runneren. |
| `GLOBAL_RUNNER_KEY` | Den medfølgende globale Runneren, som kjører JavaScript-trinnene til alle prosjekter. |

> [!IMPORTANT]
> Angi hemmelighetene før første start, og behold dem etterpå. PostgreSQL tar bare passordet sitt når den oppretter databasen, og endrer du `ENCRYPTION_SECRET` senere, blir hver verdi som er kryptert med den gamle, uleselig. Er `DATABASE_PASSWORD` fortsatt plassholderen ved første start, gir `npm start` den en tilfeldig verdi før PostgreSQL oppretter databasen sin.

### Start Status200

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

Første start tar flere minutter: Docker laster ned imagene, og Status200 oppretter databasene sine. `npm start` venter til hver del svarer, og avslutter med **Status200 is up!**

### Opprett den første kontoen

Åpne `http://` etterfulgt av `HOST` (for eksempel `http://localhost`) og registrer deg. Den første kontoen på en ny instans blir hovedadministratoren, som kan åpne Admin Dashboard på `/admin`.

Alle som kan nå siden, kan registrere seg etter deg. For å hindre det åpner du Admin Dashboard, går til **Innstillinger > Autentisering** og slår av **Tillat registrering**. Personer du inviterer til et prosjekt, kan fortsatt opprette kontoen sin.
:::

## Sett opp HTTPS

Status200 leverer vanlig HTTP til du velger én av to måter å legge til HTTPS på:

| | La Status200 hente et sertifikat | Bruk din egen reverse proxy |
| --- | --- | --- |
| **TLS avsluttes i** | Status200s `ingress`, med et gratis sertifikat fra Let's Encrypt som den fornyer selv | Proxyen din: Caddy, Nginx eller en lastbalanserer |
| **Du trenger** | Et offentlig domenenavn som peker på serveren, og port 80 og 443 som kan nås fra internett | En proxy og et sertifikat for domenet ditt |
| **Innstillinger** | `PROVISION_SSL=true`, `HTTP_PROTOCOL=https` | `PROVISION_SSL=false`, `HTTP_PROTOCOL=https`, `TRUSTED_PROXY_HOPS=2` |
| **Statussider på egne domener** | Fungerer uten ekstra oppsett | Proxyen din må også betjene de domenene |

Hvis du legger statussider eller dashbord på egne domener, er det enklest å la Status200 håndtere TLS: Ingressen bestiller og leverer selv sertifikatene for de domenene.

Med `HTTP_PROTOCOL=https` bygger Status200 HTTPS-lenker, holder påloggingsinformasjonskapsler på HTTPS og ber nettlesere om å nå `HOST`-en din bare over HTTPS. En nettleser holder seg til det i ett år, på alle porter for det navnet, så hvis `HOST` en dag må svare over vanlig HTTP igjen, setter du `HSTS_MAX_AGE_SECONDS=0` i `config.env` en stund før: Nettlesere glemmer regelen ved neste besøk.

### La Status200 hente et sertifikat

:::steps
#### Pek domenet ditt mot serveren

Opprett en DNS-post `A` (eller `AAAA` for IPv6) for domenet ditt, med serverens offentlige IP-adresse som verdi. Med en `AAAA`-post slår du også på IPv6 for Status200: se [Besøkendes adresser](#besøkendes-adresser).

#### Slå på henting av sertifikater

Angi disse verdiene i `config.env`:

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

`HOST` må være et domenenavn: Status200 kan ikke få et sertifikat for en IP-adresse eller for `localhost`.

#### Start på nytt med de nye innstillingene

```bash
npm start
```

#### Åpne instansen over HTTPS

Åpne `https://status200.example.com`. Status200 bestiller sertifikatet når den starter, sjekker det deretter hver time og fornyer det når det er mindre enn 30 dager igjen. Til det første sertifikatet kommer, vanligvis i løpet av noen minutter, leverer ingressen et midlertidig selvsignert sertifikat, og nettleseren advarer deg.
:::

### Bruk din egen reverse proxy

Disse stegene kjører proxyen på samme server som Status200. Kjører proxyen din på en annen maskin, hopper du over det første steget, peker proxyen mot port 80 på denne serveren og lar bare proxyen nå port 80 og 443 med brannmuren til skyleverandøren din: en besøkende som når Status200 utenom proxyen, kan velge adressen Status200 teller vedkommende etter.

:::steps
#### Flytt ingressen bort fra port 80 og 443

Proxyen trenger port 80 og 443, så flytt ingressen til andre porter, publisert bare på serverens loopback-adresse `127.0.0.1`, slik at besøkende bare når Status200 gjennom proxyen din. Proben og Runneren bruker vertens nettverk og når Status200 gjennom `http://localhost`, så de flytter 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
```

#### Fortell Status200 at den står bak en proxy

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

`HTTP_PROTOCOL=https` får lenkene Status200 bygger til å bruke HTTPS. `TRUSTED_PROXY_HOPS=2` teller proxyen din og Status200s ingress, så Status200 leser den besøkendes ekte adresse for IP-tillatelseslister og hastighetsbegrensninger. Legg til én for hver ekstra proxy som legger til i `X-Forwarded-For`, som et CDN eller en lastbalanserer.

#### Start Status200 på nytt på de nye portene

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

`npm start` sjekker `http://localhost` på port 80, der proxyen din skal ligge, så sjekk den nye porten selv. Skriptet avslutter med **Status200 is up!**

#### Konfigurer proxyen

:::tabs
@tab Caddy
```text title="Caddyfile"
status200.example.com {
	reverse_proxy localhost:8080
}
```
Caddy henter og fornyer sertifikatet selv, omdirigerer HTTP til HTTPS og slipper WebSocket-tilkoblinger gjennom. Last inn Caddy på nytt etter at du har endret filen, for eksempel 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;
    }
}
```
Sertifikatbanene er der Certbot legger et sertifikat fra Let's Encrypt; bruk banene til ditt eget sertifikat hvis det kommer fra et annet sted. Sjekk filen og last inn Nginx på nytt med `sudo nginx -t && sudo systemctl reload nginx`.
:::

Begge sender `X-Forwarded-Proto`, som forteller Status200 at en besøkende kom over HTTPS. Alle andre proxyer må også sende den, ellers holdes ikke påloggingsinformasjonskapslene for statussider og dashbord på egne domener på HTTPS.

#### Åpne instansen gjennom proxyen

Åpne `https://status200.example.com`. Du skal se påloggingssiden til Status200, levert med proxyens sertifikat.
:::

> [!NOTE]
> Bak din egen proxy sender du telemetri over OTLP/HTTP (`/otlp`). OTLP over gRPC når bare Status200 når dens egen ingress avslutter TLS (`PROVISION_SSL=true`).

## Besøkendes adresser

Status200 teller hver besøkende etter adressen vedkommende kobler til fra: påloggingsgrensene, de andre grensene per adresse og IP-tillatelseslistene for statussider og dashbord leser den alle. To oppsett trenger en innstilling for at den adressen skal være den besøkendes egen:

| Oppsett | Innstilling |
| --- | --- |
| Folk når Status200 over IPv6, for eksempel gjennom en `AAAA`-post | IPv6 på Status200s nettverk, i `docker-compose.override.yml` |
| Din egen reverse proxy står foran Status200 | `TRUSTED_PROXY_HOPS=2`, med ingressen publisert på `127.0.0.1` (se [Bruk din egen reverse proxy](#bruk-din-egen-reverse-proxy)) |

Uten IPv6 på Status200s nettverk sender Docker hver besøkende som kommer over IPv6 videre til Status200 fra én adresse av sin egen, og Status200 teller dem alle som én besøkende: én persons mislykkede pålogginger kan låse de andre ute. Å slå på IPv6 krever Docker Engine 27 eller nyere (`docker version` viser din).

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

Opprett `docker-compose.override.yml` ved siden av `docker-compose.yml`, eller legg dette til i den du har; `npm start` og `npm run update` leser den:

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

### Start Status200 på nytt

```bash
npm stop
npm start
```

Status200 stopper og starter igjen med IPv6 på nettverket sitt. Dataene dine beholdes. Docker kan ikke fjerne et nettverk som en egen container fortsatt er koblet til, for eksempel en reverse proxy: koble den fra Status200s nettverk først, og koble den til igjen etterpå. Stopper `npm start` med `has active endpoints`, kobler du den fra og kjører `npm stop` og `npm start` på nytt.

### Sjekk nettverket

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

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

Når flere personer logger på fra den samme private nettverksadressen, sier siden **Status200-tilstand** i Admin Dashboard fra, med innstillingen som endrer det.

## Sjekkliste for produksjon

Docker Compose kjører én kopi av hver tjeneste på én server, noe som passer for små team og homelab. Gå gjennom denne listen før du stoler på det.

| Område | Hva du gjør |
| --- | --- |
| **Hemmeligheter** | Ingen verdi i `config.env` er fortsatt en plassholder `please-change-this-to-random-value`. Se [Generer tilfeldige hemmeligheter](#generer-tilfeldige-hemmeligheter), og [Bytt databasepassordet](#bytt-databasepassordet) for en installasjon som startet med plassholderen i `DATABASE_PASSWORD`. |
| **HTTPS** | Folk når Status200 over HTTPS, og `HTTP_PROTOCOL=https` er satt. Se [Sett opp HTTPS](#sett-opp-https). |
| **Registreringer** | Når teamet ditt har kontoer, slår du av **Tillat registrering** under **Innstillinger > Autentisering** i Admin Dashboard. |
| **Brannmur** | Bare port 80 og 443 (og SSH) er åpne mot internett. Status200 publiserer PostgreSQLs port 5400 bare på `127.0.0.1`. Lukk alle andre porter du publiserer, med skyleverandørens brannmur: `ufw`-regler gjelder ikke porter som Docker publiserer. |
| **Besøkendes adresser** | Siden **Status200-tilstand** i Admin Dashboard sier ikke fra om at flere personer logger på fra den samme adressen. Se [Besøkendes adresser](#besøkendes-adresser). |
| **Sikkerhetskopier** | PostgreSQL sikkerhetskopieres hver dag, og kopiene forlater serveren. Se [Sikkerhetskopiering og gjenoppretting](#sikkerhetskopiering-og-gjenoppretting). |
| **E-post** | En e-postserver er satt opp under **Innstillinger > Varsler > E-poster** i Admin Dashboard, slik at Status200 kan sende invitasjoner og varsler. Se [SMTP](/docs/emails/smtp). |
| **Disk** | Ledig plass overvåkes. ClickHouse vokser med telemetrien du beholder (se [Dimensjonering og kapasitetsplanlegging](/docs/installation/sizing)); loggen til hver container er begrenset til 1000 MB. |
| **Oppdateringer** | Status200 oppdateres minst én gang i uken. Det kommer ofte nye releaser. Se [Oppdater Status200](#oppdater-oneuptime). |
| **Høy tilgjengelighet** | Hvis du trenger det, går du over til [Helm-chartet](https://artifacthub.io/packages/helm/status200/status200) på Kubernetes. |

### Bytt databasepassordet

PostgreSQL beholder passordet den ble opprettet med, så endrer du bare `DATABASE_PASSWORD` i `config.env`, stenger du Status200 ute fra databasen sin. For å gi en installasjon som startet med plassholderen et eget passord, endrer du det i PostgreSQL og i `config.env` samtidig, og starter deretter Status200 på nytt:

```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
```

Har du satt `DATABASE_BACKUP_PASSWORD` og `DATABASE_RESTORE_PASSWORD`, gir du dem også den nye verdien.

## Sikkerhetskopiering og gjenoppretting

PostgreSQL inneholder alt du konfigurerer: monitorer, hendelser, statussider, brukere. `npm run backup` dumper det til en fil i mappen `Backups`.

:::steps
### Gi sikkerhetskopiskriptet databasepassordet

Sett `DATABASE_BACKUP_PASSWORD` i `config.env` til verdien av `DATABASE_PASSWORD`. Skriptet leser `config.env` som ren tekst, så `${DATABASE_PASSWORD}` som følger med, blir aldri fylt ut.

### Kjør sikkerhetskopieringen

```bash
npm run backup
```

Det ber om sudo-passordet ditt og skriver `Backups/db-<day of the month>.backup`, slik at daglige sikkerhetskopier erstatter dem fra en måned tidligere. Kjør det minst én gang om dagen.

### Kopier sikkerhetskopiene bort fra serveren

En sikkerhetskopi på samme disk som databasen overlever ikke at den disken går tapt.
:::

Bare selve serveren når PostgreSQL: Den svarer på port 5400 på `127.0.0.1`. For å ta sikkerhetskopi av den fra en annen maskin åpner du en SSH-tunnel fra den maskinen, og kobler deretter til maskinens egen port 5400:

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

:::details Publiser PostgreSQL på en adresse i et privat nettverk
Hvis et verktøy på det private nettverket ditt må nå PostgreSQL uten tunnel, publiserer du den også på serverens adresse i det nettverket, på en egen port. Opprett `docker-compose.override.yml` ved siden av `docker-compose.yml`; `npm start` og `npm run update` leser den:

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

Bruk serverens egen private adresse i stedet for `10.0.0.5`, aldri en offentlig, og gi først PostgreSQL et eget passord (se [Bytt databasepassordet](#bytt-databasepassordet)). Kjør deretter `npm start`, så svarer PostgreSQL også på port 5401 på den adressen.
:::

ClickHouse holder telemetrien din i Docker-volumet `status200_clickhouse`, og ingen skript sikkerhetskopierer det. Hvis du må beholde den telemetrien, sikkerhetskopierer du volumet med et ClickHouse-verktøy som [clickhouse-backup](https://github.com/Altinity/clickhouse-backup), eller kopierer det mens Status200 er stoppet.

For å gjenopprette PostgreSQL setter du verdiene `DATABASE_RESTORE_*` i `config.env`: `DATABASE_RESTORE_PASSWORD` til verdien av `DATABASE_PASSWORD`, som for sikkerhetskopier, og `DATABASE_RESTORE_FILENAME` til sikkerhetskopien som skal gjenopprettes, for eksempel `db-31.backup`. Kjør deretter `bash restore.sh`. Databasen det gjenoppretter til, må allerede finnes; i en kjørende installasjon gjør den det.

> [!CAUTION]
> `restore.sh` sletter hvert objekt fra sikkerhetskopien i måldatabasen før det opprettes på nytt. Det spør før det starter; sjekk databasenavnet det viser.

## Oppdater Status200

Ta sikkerhetskopi først, og kjør deretter:

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

`npm run update` ber om sudo-passordet ditt, legger til nye innstillinger fra `config.example.env` i `config.env` (dine egne verdier blir værende), henter de nye imagene og starter Status200 på nytt. Som `npm start` avslutter det med **Status200 is up!**

Å gå over til en ny hovedversjon (fra 13 til 14, for eksempel) kan kreve mer: Les [Oppgradering av Status200](/docs/installation/upgrading) før du begynner.

`APP_TAG=release` i `config.env` henter alltid den nyeste releasen av Community Edition. For å bli på én versjon setter du `APP_TAG` til nummeret, for eksempel `14.0.22`. For Enterprise Edition er taggene `enterprise-release` og `enterprise-14.0.22`.

## Avinstaller Status200

Stopp Status200 og fjern containerne og nettverket:

```bash
npm run down
```

Dataene dine blir værende i volumene `status200_postgres` og `status200_clickhouse`, og mappen `oneuptime` beholder `config.env` og sikkerhetskopiene dine. For å slette dataene også:

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

Slett deretter mappen `oneuptime`.

> [!CAUTION]
> `--volumes` sletter hver monitor, hendelse, bruker og all telemetri for godt. Ta sikkerhetskopi først hvis du kan få bruk for noe av det.

## Feilsøking

:::details Docker sier "permission denied" når du kjører npm start
Brukeren din når ikke Docker-daemonen. Legg den til i gruppen `docker`, og logg deretter ut og inn igjen:

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

:::details Ingressen kan ikke starte fordi port 80 eller 443 er i bruk
Et annet program på serveren, ofte en webserver, holder porten. Stopp det, eller flytt ingressen til andre porter og sett programmet foran Status200 som beskrevet i [Bruk din egen reverse proxy](#bruk-din-egen-reverse-proxy).
:::

:::details npm start avslutter med "Maximum retries reached"
Sjekken som avslutter `npm start`, ga opp før Status200 svarte. Første start kan ta lenger tid enn sjekken venter, mens imagene lastes ned og databasene opprettes. Se hva som kjører, og les loggene:

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

Når hver container kjører, kjører du sjekken på nytt med `npm run status-check`. Hvis du flyttet ingressen bort fra port 80, sjekker du i stedet den nye porten: `bash Tests/Scripts/status-check.sh localhost:8080`.
:::

:::details Noen sider lastes, men liveoppdateringer eller opplastinger feiler
Åpne Status200 på adressen i `HOST`. Ingressen ruter forespørsler etter vertsnavn: Bare `HOST` og `localhost` når hele applikasjonen, og ethvert annet navn, som serverens IP-adresse, behandles som domenet til en statusside. Sett `HOST` til navnet folk bruker, og kjør deretter `npm start`.
:::

:::details Registrering eller innlogging feiler med "Page not found"
Registreringssiden lastes, men registrering feiler med `Page not found - /identity/signup`, og innlogging med `Page not found - /identity/login`. Forespørselen nådde Status200 under et annet vertsnavn enn `HOST`, så ingressen rutet den som en statussides eget domene, der Status200s egen registrering og innlogging ikke tilbys. Sjekk begge deler:

- `HOST` er adressen folk åpner, med porten hvis de bruker en, som `status200.example.com:8080`. Kjør `npm start` etter at du har endret den.
- En proxy foran Status200 sender videre vertsnavnet nettleseren ba om. Caddy gjør det som standard, Nginx med `proxy_set_header Host $host;` som i [Bruk din egen reverse proxy](#bruk-din-egen-reverse-proxy), og Apache med `ProxyPreserveHost On`.
:::

:::details Nettleseren advarer om sertifikatet etter at du satte PROVISION_SSL
Til Let's Encrypt utsteder sertifikatet, leverer ingressen et midlertidig selvsignert sertifikat. Hvis advarselen varer i mer enn noen minutter, sjekker du at:

- `HOST` er et domenenavn, ikke en IP-adresse og ikke `localhost`.
- Domenets DNS-post peker mot denne serveren.
- Port 80 kan nås fra internett, slik at Let's Encrypt kan validere domenet.

Når en bestilling feiler, logger appen en feil som begynner med `CoreSSL:EnsurePrimaryHostCertificate`, etterfulgt av årsaken:

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

:::details Den medfølgende proben viser Frakoblet etter at du flyttet ingressens port
Admin Dashboard viser proben under **Innstillinger > Overvåking > Globale prober**. Den når Status200 på `GLOBAL_PROBE_1_STATUS200_URL`, som er `http://localhost` (port 80) som standard. Sett den til ingressens nye port, for eksempel `http://localhost:8080`, sett `ONEUPTIME_RUNNER_STATUS200_URL` på samme måte, og start Status200 på nytt.
:::

## Neste steg

:::cards
- [Oppgradering av Status200](/docs/installation/upgrading): Hva hver hovedversjon krever av deg.
- [Dimensjonering og kapasitetsplanlegging](/docs/installation/sizing): Planlegg minne og disk for telemetrien din.
- [Selvdriftet arkitektur](/docs/self-hosted/architecture): Hvordan komponentene henger sammen.
- [Enterprise Edition](/docs/self-hosted/enterprise): Hva Enterprise-imaget legger til, og lisensen.
:::