# Docker Compose

Draai een volledige, gratis Status200-instantie op één Linux-server met Docker Compose. Deze pagina brengt u van een nieuwe server naar een draaiende instantie en behandelt daarna HTTPS, het beveiligen voor productie, back-ups, updates en verwijderen. Wilt u in plaats daarvan aan de code van Status200 zelf werken, zie dan [Lokale ontwikkeling](/docs/installation/local-development).

:::cards
- [Status200 installeren](#oneuptime-installeren): Van een nieuwe server naar uw eerste account in zes stappen.
- [HTTPS instellen](#https-instellen): Laat Status200 een certificaat halen, of zet uw eigen proxy ervoor.
- [Checklist voor productie](#checklist-voor-productie): Wat geregeld moet zijn voordat er echt verkeer binnenkomt.
- [Status200 bijwerken](#oneuptime-bijwerken): Overstappen op de nieuwste release.
:::

## Hoe het werkt

Docker Compose draait elk onderdeel van Status200 als container op uw server. Al het verkeer komt binnen via de container `ingress`, die het naar de `app` doorstuurt. De app bewaart zijn gegevens in PostgreSQL, ClickHouse en Valkey. Een meegeleverde probe voert de controles van uw monitors uit en meldt de resultaten terug via de ingress.

```mermaid title="De Docker Compose-installatie"
flowchart TB
    Users["Gebruikers en agents"]
    Proxy["Uw reverse<br/>proxy, optioneel"]
    Targets["Sites die u bewaakt"]
    subgraph Server["Uw server"]
        Ingress["ingress"]
        App["app"]
        Probe["probe-1"]
        Runner["runner"]
        subgraph Data["Gegevensopslag"]
            direction LR
            PG[("postgres")]
            CH[("clickhouse")]
            VK[("valkey")]
        end
    end
    Users -->|HTTPS| Proxy
    Proxy -->|HTTP| Ingress
    Users -.->|"zonder proxy"| Ingress
    Ingress --> App
    App --> PG
    App --> CH
    App --> VK
    Probe -->|resultaten| Ingress
    Runner -->|taken| Ingress
    Probe -->|controles| Targets
    Data ~~~ Probe
    Data ~~~ Runner
```

| Service | Image | Wat hij doet |
| --- | --- | --- |
| `ingress` | `status200/nginx` | Ontvangt al het verkeer op poort 80 en 443 en stuurt het door naar de app. Levert HTTPS als Status200 het certificaat beheert. |
| `app` | `status200/app` | Het dashboard, de API, statuspagina's, de opname van telemetrie en de achtergrondworkers. |
| `probe-1` | `status200/probe` | Een globale probe die de controles van uw monitors uitvoert. Hij gebruikt het netwerk van de host. |
| `runner` | `status200/runner` | De Runner van de instantie, die AI-codecorrecties uitvoert. Hij gebruikt het netwerk van de host. |
| `postgres` | `postgres:15` | Configuratie en status: monitors, incidenten, gebruikers. Opgeslagen in het volume `postgres`. |
| `clickhouse` | `clickhouse/clickhouse-server:26.7` | Telemetrie: logs, metrics, traces en exceptions. Opgeslagen in het volume `clickhouse`. |
| `valkey` | `valkey/valkey:9.1-alpine` | Cache en wachtrijen. Hij bewaart niets op schijf. |

> [!NOTE]
> De service `valkey` draait [Valkey](https://valkey.io), de BSD-gelicentieerde fork van Redis 7.2, geconfigureerd via de instellingen `VALKEY_*` in `config.env`. Elke server die het Redis-protocol spreekt, werkt — wijs `VALKEY_HOST` naar een beheerde Redis als u dat liever hebt. Tot 13.0.0 heetten deze instellingen `REDIS_*`; de oude namen worden nog steeds gelezen, de container luistert nog steeds naar de hostnaam `redis`, en `npm run update` herschrijft ze niet, dus een oudere `config.env` hoeft niet te worden aangepast.

Gebruik voor productie op grote schaal, of als u hoge beschikbaarheid nodig hebt, in plaats daarvan de [Helm-chart](https://artifacthub.io/packages/helm/status200/status200) op Kubernetes: Docker Compose draait van elke service één exemplaar op één server.

## Vereisten

Kies de grootte van de server op basis van wat u erop gaat draaien. Telemetrie (logs, metrics, traces) bepaalt het geheugen en de schijf; zie [Sizing en capaciteitsplanning](/docs/installation/sizing) zodra u uw volumes kent.

| | Aanbevolen | Minimum voor een homelab |
| --- | --- | --- |
| **Geheugen** | 16 GB | 8 GB |
| **CPU** | 8 cores | 4 cores |
| **Schijf** | 400 GB | 20 GB |
| **Systeem** | Ubuntu 22.04, of een ander Linux op basis van Debian, Ubuntu of RHEL | Hetzelfde |
| **Architectuur** | x86-64 (`amd64`) of ARM (`arm64`) | Hetzelfde |

Het minimum voor een homelab is geschikt voor persoonlijk en experimenteel gebruik — sommigen draaien Status200 op een Raspberry Pi.

U hebt ook nodig:

- **Docker** met de plugin **Docker Compose v2** (het commando `docker compose`).
- **Git**, om Status200 op te halen.
- **Node.js en npm**, die de scripts `npm start` en `npm run update` uitvoeren die om Docker Compose heen zijn gebouwd.
- **Poorten 80 en 443** vrij op de server. De tabel hieronder toont elke poort die Status200 op de host gebruikt.

| Hostpoort | Gebruikt door | Instelling | Waarvoor |
| --- | --- | --- | --- |
| 80 | `ingress` | `ONEUPTIME_HTTP_PORT` | Het dashboard, de API, de opname van telemetrie en de validatie door Let's Encrypt. |
| 443 | `ingress` | `STATUS_PAGE_HTTPS_PORT` | HTTPS voor uw instantie als Status200 het certificaat beheert, en voor statuspagina's en dashboards op eigen domeinen. |
| 5400 | `postgres` | Ingesteld in `docker-compose.yml` | Laat `npm run backup` en `restore.sh` PostgreSQL bereiken vanaf de server zelf. Hij is alleen op `127.0.0.1` gepubliceerd. |
| 3874 | `probe-1` | `GLOBAL_PROBE_1_PORT` | De eigen server van de probe. Niets buiten de server heeft hem nodig. |
| 3876 | `runner` | `ONEUPTIME_RUNNER_PORT` | De eigen server van de Runner. Niets buiten de server heeft hem nodig. |

Er is ook een [video-uitleg](https://youtu.be/j1SWmMW2oL4) van de installatie.

## Status200 installeren

:::steps
### Kloon de release-branch

De branch `release` bevat de bestanden van de nieuwste release.

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

### Maak config.env aan

Alle instellingen van Status200 staan in `config.env`. Begin met het voorbeeld:

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

### Stel de hostnaam in

Open `config.env` en stel `HOST` in op de domeinnaam of het IP-adres waarmee mensen Status200 bereiken, zonder `http://`. Houd `localhost` alleen aan om Status200 op uw eigen computer uit te proberen.

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

### Genereer willekeurige geheimen

Het voorbeeldbestand bevat tijdelijke geheimen die openbaar op GitHub staan. Vervang elk ervan door een eigen willekeurige waarde:

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

Het laatste commando geeft `0`: er is geen tijdelijke waarde meer over. De lus gebruikt GNU `sed`, dat elke Linux-server heeft. Dit zijn de instellingen die hij invult:

| Instelling | Wat ze beschermt |
| --- | --- |
| `ONEUPTIME_SECRET` | Aanroepen tussen de eigen services van Status200. |
| `ENCRYPTION_SECRET` | De geheimen die Status200 opslaat, zoals integratietokens en SMTP-wachtwoorden, en de aanmeldtokens die het uitgeeft. |
| `DATABASE_PASSWORD`, `CLICKHOUSE_PASSWORD`, `VALKEY_PASSWORD` | De drie gegevensopslagen. |
| `REGISTER_PROBE_KEY` | Het registreren van probes bij uw instantie. |
| `GLOBAL_PROBE_1_KEY`, `GLOBAL_PROBE_2_KEY` | De globale probes die Docker Compose kan draaien (`probe-1` draait standaard). |
| `STATUS200_RUNNER_KEY` | De meegeleverde Runner. |
| `GLOBAL_RUNNER_KEY` | De meegeleverde globale Runner, die de JavaScript-stappen van alle projecten uitvoert. |

> [!IMPORTANT]
> Stel de geheimen in vóór de eerste start en houd ze daarna aan. PostgreSQL neemt zijn wachtwoord alleen over bij het aanmaken van zijn database, en `ENCRYPTION_SECRET` later wijzigen maakt elke waarde die met de oude is versleuteld onleesbaar. Is `DATABASE_PASSWORD` bij de eerste start nog de tijdelijke waarde, dan geeft `npm start` het een willekeurige waarde voordat PostgreSQL zijn database aanmaakt.

### Start Status200

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

De eerste start duurt enkele minuten: Docker downloadt de images en Status200 maakt zijn databases aan. `npm start` wacht tot elk onderdeel antwoordt en eindigt met **Status200 is up!**

### Maak het eerste account aan

Open `http://` gevolgd door uw `HOST` (bijvoorbeeld `http://localhost`) en registreer u. Het eerste account van een nieuwe instantie wordt de hoofdbeheerder ervan, die het Admin Dashboard op `/admin` kan openen.

Iedereen die de pagina kan bereiken, kan zich na u registreren. Om dat te voorkomen, opent u het Admin Dashboard, gaat u naar **Instellingen > Authenticatie** en schakelt u **Registratie toestaan** uit. Mensen die u voor een project uitnodigt, kunnen nog steeds hun account aanmaken.
:::

## HTTPS instellen

Status200 levert gewoon HTTP totdat u een van twee manieren kiest om HTTPS toe te voegen:

| | Status200 een certificaat laten halen | Uw eigen reverse proxy gebruiken |
| --- | --- | --- |
| **TLS eindigt bij** | De `ingress` van Status200, met een gratis Let's Encrypt-certificaat dat hij zelf vernieuwt | Uw proxy: Caddy, Nginx of een load balancer |
| **U hebt nodig** | Een openbare domeinnaam die naar de server wijst, en poorten 80 en 443 bereikbaar vanaf internet | Een proxy en een certificaat voor uw domein |
| **Instellingen** | `PROVISION_SSL=true`, `HTTP_PROTOCOL=https` | `PROVISION_SSL=false`, `HTTP_PROTOCOL=https`, `TRUSTED_PROXY_HOPS=2` |
| **Statuspagina's op eigen domeinen** | Werken zonder extra instellingen | Uw proxy moet die domeinen ook bedienen |

Als u statuspagina's of dashboards op eigen domeinen zet, is Status200 TLS laten afhandelen de eenvoudigste opzet: de ingress bestelt de certificaten van die domeinen zelf en levert ze uit.

Met `HTTP_PROTOCOL=https` bouwt Status200 HTTPS-links, houdt het aanmeldcookies op HTTPS en vraagt het browsers om uw `HOST` alleen via HTTPS te bereiken. Een browser houdt zich daar een jaar aan, op elke poort van die naam. Moet `HOST` ooit weer via gewoon HTTP antwoorden, zet dan een tijd van tevoren `HSTS_MAX_AGE_SECONDS=0` in `config.env`: browsers vergeten de regel bij hun volgende bezoek.

### Status200 een certificaat laten halen

:::steps
#### Wijs uw domein naar de server

Maak voor uw domein een DNS-record `A` (of `AAAA` voor IPv6) aan, met het openbare IP-adres van de server als waarde. Met een `AAAA`-record zet u ook IPv6 aan voor Status200: zie [Adressen van bezoekers](#adressen-van-bezoekers).

#### Schakel het aanvragen van certificaten in

Stel deze waarden in `config.env` in:

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

`HOST` moet een domeinnaam zijn: Status200 kan geen certificaat krijgen voor een IP-adres of voor `localhost`.

#### Herstart met de nieuwe instellingen

```bash
npm start
```

#### Open uw instantie via HTTPS

Open `https://status200.example.com`. Status200 bestelt het certificaat bij het starten, controleert het daarna elk uur en vernieuwt het als er minder dan 30 dagen over zijn. Totdat het eerste certificaat binnen is, meestal binnen enkele minuten, levert de ingress een tijdelijk zelfondertekend certificaat en waarschuwt uw browser u.
:::

### Uw eigen reverse proxy gebruiken

Deze stappen draaien de proxy op dezelfde server als Status200. Draait uw proxy op een andere machine, sla dan de eerste stap over, wijs de proxy naar poort 80 van deze server en laat met de firewall van uw cloudprovider alleen de proxy poort 80 en 443 bereiken: een bezoeker die Status200 buiten de proxy om bereikt, kan het adres kiezen waarop Status200 hem telt.

:::steps
#### Haal de ingress van poort 80 en 443 af

De proxy heeft poort 80 en 443 nodig, dus verplaats de ingress naar andere poorten, alleen gepubliceerd op het loopbackadres `127.0.0.1` van deze server, zodat bezoekers Status200 alleen via uw proxy bereiken. De probe en de Runner gebruiken het netwerk van de host en bereiken Status200 via `http://localhost`, dus ze verhuizen mee:

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

#### Vertel Status200 dat het achter een proxy staat

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

`HTTP_PROTOCOL=https` laat de links die Status200 bouwt HTTPS gebruiken. `TRUSTED_PROXY_HOPS=2` telt uw proxy en de ingress van Status200, zodat Status200 voor IP-allowlists en rate limits het echte adres van de bezoeker leest. Tel er een bij voor elke volgende proxy die iets toevoegt aan `X-Forwarded-For`, zoals een CDN of een load balancer.

#### Herstart Status200 op de nieuwe poorten

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

`npm start` controleert `http://localhost` op poort 80, waar uw proxy komt, dus controleer de nieuwe poort zelf. Het script eindigt met **Status200 is up!**

#### Configureer de proxy

:::tabs
@tab Caddy
```text title="Caddyfile"
status200.example.com {
	reverse_proxy localhost:8080
}
```
Caddy haalt en vernieuwt het certificaat zelf, stuurt HTTP door naar HTTPS en laat WebSocket-verbindingen door. Laad Caddy opnieuw nadat u het bestand hebt gewijzigd, bijvoorbeeld met `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;
    }
}
```
De certificaatpaden zijn de plekken waar Certbot een Let's Encrypt-certificaat neerzet; gebruik de paden van uw eigen certificaat als het ergens anders vandaan komt. Controleer het bestand en laad Nginx opnieuw met `sudo nginx -t && sudo systemctl reload nginx`.
:::

Beide sturen `X-Forwarded-Proto` mee, dat Status200 vertelt dat een bezoeker via HTTPS kwam. Elke andere proxy moet het ook sturen, anders blijven de aanmeldcookies van statuspagina's en dashboards op uw eigen domeinen niet op HTTPS.

#### Open uw instantie via de proxy

Open `https://status200.example.com`. U zou de aanmeldpagina van Status200 moeten zien, geleverd met het certificaat van uw proxy.
:::

> [!NOTE]
> Stuur telemetrie achter uw eigen proxy via OTLP/HTTP (`/otlp`). OTLP via gRPC bereikt Status200 alleen als zijn eigen ingress TLS afhandelt (`PROVISION_SSL=true`).

## Adressen van bezoekers

Status200 telt elke bezoeker op het adres waarvandaan hij verbinding maakt: de aanmeldlimieten, de andere limieten per adres en de IP-allowlists van statuspagina's en dashboards lezen het allemaal. Twee opstellingen hebben een instelling nodig om dat adres het eigen adres van de bezoeker te laten zijn:

| Opstelling | Instelling |
| --- | --- |
| Mensen bereiken Status200 via IPv6, bijvoorbeeld via een `AAAA`-record | IPv6 op het netwerk van Status200, in `docker-compose.override.yml` |
| Uw eigen reverse proxy staat voor Status200 | `TRUSTED_PROXY_HOPS=2`, met de ingress gepubliceerd op `127.0.0.1` (zie [Uw eigen reverse proxy gebruiken](#uw-eigen-reverse-proxy-gebruiken)) |

Zonder IPv6 op het netwerk van Status200 geeft Docker elke bezoeker die via IPv6 komt vanaf een eigen adres door aan Status200, en Status200 telt hen allemaal als één bezoeker: de mislukte aanmeldingen van één persoon kunnen de anderen buitensluiten. IPv6 aanzetten vraagt Docker Engine 27 of nieuwer (`docker version` toont de uwe).

:::steps
### Zet IPv6 aan

Maak `docker-compose.override.yml` aan naast `docker-compose.yml`, of voeg dit toe aan het bestand dat u al hebt; `npm start` en `npm run update` lezen het:

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

### Herstart Status200

```bash
npm stop
npm start
```

Status200 stopt en start opnieuw, met IPv6 op zijn netwerk. Uw gegevens blijven bewaard. Docker kan geen netwerk verwijderen waaraan nog een eigen container gekoppeld is, zoals een reverse proxy: ontkoppel die eerst van het netwerk van Status200 en koppel hem daarna weer. Stopt `npm start` met `has active endpoints`, ontkoppel hem dan en voer `npm stop` en `npm start` opnieuw uit.

### Controleer het netwerk

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

Het toont `"EnableIPv6": true,`.
:::

Als meerdere mensen zich aanmelden vanaf één privénetwerkadres, meldt de pagina **Status200-gezondheid** van het Admin Dashboard dat, met de instelling die het verandert.

## Checklist voor productie

Docker Compose draait van elke service één exemplaar op één server, wat past bij kleine teams en homelabs. Loop deze lijst door voordat u erop gaat vertrouwen.

| Onderdeel | Wat te doen |
| --- | --- |
| **Geheimen** | Geen enkele waarde in `config.env` is nog een tijdelijke waarde `please-change-this-to-random-value`. Zie [Genereer willekeurige geheimen](#genereer-willekeurige-geheimen), en [Wijzig het databasewachtwoord](#wijzig-het-databasewachtwoord) voor een installatie die startte met de tijdelijke waarde in `DATABASE_PASSWORD`. |
| **HTTPS** | Mensen bereiken Status200 via HTTPS en `HTTP_PROTOCOL=https` is ingesteld. Zie [HTTPS instellen](#https-instellen). |
| **Registraties** | Zodra uw team accounts heeft, schakelt u **Registratie toestaan** uit onder **Instellingen > Authenticatie** in het Admin Dashboard. |
| **Firewall** | Alleen poort 80 en 443 (en SSH) staan open naar internet. Status200 publiceert poort 5400 van PostgreSQL alleen op `127.0.0.1`. Sluit elke andere poort die u publiceert af met de firewall van uw cloudprovider: `ufw`-regels gelden niet voor poorten die Docker publiceert. |
| **Adressen van bezoekers** | De pagina **Status200-gezondheid** van het Admin Dashboard meldt niet dat meerdere mensen zich aanmelden vanaf één adres. Zie [Adressen van bezoekers](#adressen-van-bezoekers). |
| **Back-ups** | PostgreSQL wordt elke dag geback-upt en de kopieën verlaten de server. Zie [Back-up en herstel](#back-up-en-herstel). |
| **E-mail** | Er is een mailserver ingesteld onder **Instellingen > Meldingen > E-mails** in het Admin Dashboard, zodat Status200 uitnodigingen en meldingen kan versturen. Zie [SMTP](/docs/emails/smtp). |
| **Schijf** | De vrije ruimte wordt bewaakt. ClickHouse groeit met de telemetrie die u bewaart (zie [Sizing en capaciteitsplanning](/docs/installation/sizing)); het log van elke container is begrensd op 1000 MB. |
| **Updates** | Status200 wordt minstens één keer per week bijgewerkt. Releases verschijnen vaak. Zie [Status200 bijwerken](#oneuptime-bijwerken). |
| **Hoge beschikbaarheid** | Als u die nodig hebt, stap dan over op de [Helm-chart](https://artifacthub.io/packages/helm/status200/status200) op Kubernetes. |

### Wijzig het databasewachtwoord

PostgreSQL houdt het wachtwoord waarmee het is aangemaakt, dus als u alleen `DATABASE_PASSWORD` in `config.env` wijzigt, sluit u Status200 buiten zijn database. Om een installatie die startte met de tijdelijke waarde een eigen wachtwoord te geven, wijzigt u het tegelijk in PostgreSQL en in `config.env` en start u Status200 daarna opnieuw:

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

Hebt u `DATABASE_BACKUP_PASSWORD` en `DATABASE_RESTORE_PASSWORD` ingesteld, geef ze dan ook de nieuwe waarde.

## Back-up en herstel

PostgreSQL bevat alles wat u configureert: monitors, incidenten, statuspagina's, gebruikers. `npm run backup` dumpt het naar een bestand in de map `Backups`.

:::steps
### Geef het back-upscript het databasewachtwoord

Stel in `config.env` `DATABASE_BACKUP_PASSWORD` in op de waarde van `DATABASE_PASSWORD`. Het script leest `config.env` als platte tekst, dus de meegeleverde `${DATABASE_PASSWORD}` wordt nooit ingevuld.

### Voer de back-up uit

```bash
npm run backup
```

Het vraagt om uw sudo-wachtwoord en schrijft `Backups/db-<day of the month>.backup`, zodat dagelijkse back-ups die van een maand eerder vervangen. Voer het minstens één keer per dag uit.

### Kopieer de back-ups van de server af

Een back-up op dezelfde schijf als de database overleeft het verlies van die schijf niet.
:::

Alleen de server zelf bereikt PostgreSQL: het antwoordt op poort 5400 van `127.0.0.1`. Om er vanaf een andere machine een back-up van te maken, opent u vanaf die machine een SSH-tunnel en maakt u daarna verbinding met de eigen poort 5400 van die machine:

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

:::details PostgreSQL publiceren op een adres in een privénetwerk
Moet een tool in uw privénetwerk PostgreSQL zonder tunnel bereiken, publiceer het dan ook op het adres van de server in dat netwerk, op een eigen poort. Maak `docker-compose.override.yml` aan naast `docker-compose.yml`; `npm start` en `npm run update` lezen het:

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

Zet het eigen privéadres van de server in plaats van `10.0.0.5`, nooit een openbaar adres, en geef PostgreSQL eerst een eigen wachtwoord (zie [Wijzig het databasewachtwoord](#wijzig-het-databasewachtwoord)). Voer daarna `npm start` uit, en PostgreSQL antwoordt ook op poort 5401 van dat adres.
:::

ClickHouse bewaart uw telemetrie in het Docker-volume `status200_clickhouse`, en geen enkel script maakt daar een back-up van. Moet u die telemetrie bewaren, maak dan een back-up van het volume met een ClickHouse-tool zoals [clickhouse-backup](https://github.com/Altinity/clickhouse-backup), of kopieer het terwijl Status200 is gestopt.

Om PostgreSQL te herstellen, stelt u de waarden `DATABASE_RESTORE_*` in `config.env` in: `DATABASE_RESTORE_PASSWORD` op de waarde van `DATABASE_PASSWORD`, net als voor back-ups, en `DATABASE_RESTORE_FILENAME` op de te herstellen back-up, zoals `db-31.backup`. Voer daarna `bash restore.sh` uit. De database waarin het herstelt, moet al bestaan; bij een draaiende installatie is dat zo.

> [!CAUTION]
> `restore.sh` verwijdert elk object uit de back-up uit de doeldatabase voordat het opnieuw wordt aangemaakt. Het vraagt dit voordat het begint; controleer de databasenaam die het toont.

## Status200 bijwerken

Maak eerst een back-up en voer daarna uit:

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

`npm run update` vraagt om uw sudo-wachtwoord, voegt nieuwe instellingen uit `config.example.env` toe aan uw `config.env` (uw eigen waarden blijven staan), haalt de nieuwe images op en herstart Status200. Net als `npm start` eindigt het met **Status200 is up!**

Overstappen op een nieuwe hoofdversie (van 13 naar 14, bijvoorbeeld) kan meer vergen: lees [Status200 upgraden](/docs/installation/upgrading) voordat u begint.

`APP_TAG=release` in `config.env` haalt altijd de nieuwste release van de Community Edition op. Om op één versie te blijven, stelt u `APP_TAG` in op het nummer ervan, zoals `14.0.22`. Voor de Enterprise Edition zijn de tags `enterprise-release` en `enterprise-14.0.22`.

## Status200 verwijderen

Stop Status200 en verwijder de containers en het netwerk:

```bash
npm run down
```

Uw gegevens blijven in de volumes `status200_postgres` en `status200_clickhouse`, en de map `oneuptime` houdt `config.env` en uw back-ups. Om ook de gegevens te verwijderen:

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

Verwijder daarna de map `oneuptime`.

> [!CAUTION]
> `--volumes` verwijdert elke monitor, elk incident, elke gebruiker en alle telemetrie definitief. Maak eerst een back-up als u er nog iets van nodig zou kunnen hebben.

## Probleemoplossing

:::details Docker meldt "permission denied" als u npm start uitvoert
Uw gebruiker kan de Docker-daemon niet bereiken. Voeg hem toe aan de groep `docker`, meld u daarna af en weer aan:

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

:::details De ingress kan niet starten omdat poort 80 of 443 in gebruik is
Een ander programma op de server, vaak een webserver, houdt de poort bezet. Stop het, of verplaats de ingress naar andere poorten en zet dat programma vóór Status200, zoals beschreven in [Uw eigen reverse proxy gebruiken](#uw-eigen-reverse-proxy-gebruiken).
:::

:::details npm start eindigt met "Maximum retries reached"
De controle waarmee `npm start` eindigt, gaf op voordat Status200 antwoordde. De eerste start kan langer duren dan de controle wacht, terwijl images worden gedownload en de databases worden aangemaakt. Kijk wat er draait en lees de logs:

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

Zodra elke container draait, voert u de controle opnieuw uit met `npm run status-check`. Hebt u de ingress van poort 80 af gehaald, controleer dan in plaats daarvan de nieuwe poort: `bash Tests/Scripts/status-check.sh localhost:8080`.
:::

:::details Sommige pagina's laden, maar live-updates of uploads mislukken
Open Status200 op het adres in `HOST`. De ingress stuurt verzoeken door op basis van de hostnaam: alleen `HOST` en `localhost` bereiken de hele applicatie, en elke andere naam, zoals het IP-adres van de server, wordt behandeld als domein van een statuspagina. Stel `HOST` in op de naam die mensen gebruiken en voer daarna `npm start` uit.
:::

:::details Registreren of aanmelden mislukt met "Page not found"
De registratiepagina laadt, maar registreren mislukt met `Page not found - /identity/signup` en aanmelden met `Page not found - /identity/login`. Het verzoek bereikte Status200 onder een andere hostnaam dan `HOST`, dus de ingress stuurde het door als het eigen domein van een statuspagina, waar de registratie en aanmelding van Status200 zelf niet worden aangeboden. Controleer beide:

- `HOST` is het adres dat mensen openen, met de poort als ze er een gebruiken, zoals `status200.example.com:8080`. Voer `npm start` uit nadat u het hebt gewijzigd.
- Een proxy voor Status200 geeft de hostnaam door die de browser vroeg. Caddy doet dat standaard, Nginx met `proxy_set_header Host $host;` zoals in [Uw eigen reverse proxy gebruiken](#uw-eigen-reverse-proxy-gebruiken), en Apache met `ProxyPreserveHost On`.
:::

:::details De browser waarschuwt voor het certificaat nadat u PROVISION_SSL hebt ingesteld
Totdat Let's Encrypt het certificaat uitgeeft, levert de ingress een tijdelijk zelfondertekend certificaat. Blijft de waarschuwing langer dan een paar minuten staan, controleer dan of:

- `HOST` een domeinnaam is, geen IP-adres en niet `localhost`.
- Het DNS-record van het domein naar deze server wijst.
- Poort 80 vanaf internet bereikbaar is, zodat Let's Encrypt het domein kan valideren.

Als een bestelling mislukt, logt de app een fout die begint met `CoreSSL:EnsurePrimaryHostCertificate`, gevolgd door de reden:

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

:::details De meegeleverde probe toont Verbinding verbroken nadat u de poort van de ingress hebt verplaatst
Het Admin Dashboard toont de probe onder **Instellingen > Bewaking > Globale probes**. Hij bereikt Status200 op `GLOBAL_PROBE_1_STATUS200_URL`, standaard `http://localhost` (poort 80). Stel die in op de nieuwe poort van de ingress, bijvoorbeeld `http://localhost:8080`, stel `ONEUPTIME_RUNNER_STATUS200_URL` op dezelfde manier in en herstart Status200.
:::

## Volgende stappen

:::cards
- [Status200 upgraden](/docs/installation/upgrading): Wat elke hoofdversie van u vraagt.
- [Sizing en capaciteitsplanning](/docs/installation/sizing): Plan geheugen en schijf voor uw telemetrie.
- [Zelf gehoste architectuur](/docs/self-hosted/architecture): Hoe de onderdelen samenwerken.
- [Enterprise Edition](/docs/self-hosted/enterprise): Wat de Enterprise-image toevoegt, en de licentie ervan.
:::