richardk/iso27diy-corp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Minor changes

Browse source
This commit is contained in:
Richard Kranendonk 2026-06-06 20:39:28 +02:00
parent 7477699443
commit 4f090cab49
6 changed files with 0 additions and 752 deletions
Download patch file Download diff file Expand all files Collapse all files

5
vps@hostinger/Hostinger How-to's.md
View file

@ -1,5 +0,0 @@
[VPS Setup Guide](https://www.hostinger.com/support/5723772-how-to-connect-to-your-vps-via-ssh-at-hostinger/)
[Setting up the Firewall](https://www.hostinger.com/support/8172641-how-to-use-a-managed-vps-firewall-at-hostinger/)
[Best practices](https://www.hostinger.com/tutorials/vps-security)
[VPS monitoring with Kodee](https://www.youtube.com/watch?v=LpmOMzQDxFk)
[VPS support articles](https://www.hostinger.com/support/vps/)

228
vps@hostinger/VPS administration.md
View file

@ -1,228 +0,0 @@
# Onderhoudsplan — iso27diy.com VPS & analytics stack
## Dagelijks (geautomatiseerd)
Niets te doen — de volgende zaken lopen automatisch:
- fail2ban monitort SSH-pogingen en blokkeert aanvallers
- Docker herstart Umami en PostgreSQL bij crashes (`restart: always`)
- Nginx en fail2ban herstarten automatisch na een server-reboot (`systemctl enable`)
- Let's Encrypt vernieuwt het SSL-certificaat automatisch via Certbot
---
## Wekelijks (~10 minuten)
### Services controleren
```bash
# Nginx en fail2ban
sudo systemctl status nginx fail2ban
# Umami en PostgreSQL
cd ~/umami && docker compose ps
```
Wat je wil zien: `active (running)` voor systemd-services, `running` voor Docker containers.
### fail2ban activiteit bekijken
```bash
sudo fail2ban-client status sshd
```
Veel bans op korte tijd kan wijzen op een gerichte aanval — overweeg dan `bantime` te verhogen in `jail.local`.
### Schijfruimte controleren
```bash
df -h
```
Let op de partitie waar `/` op staat. Bij meer dan 80% gebruik actie ondernemen (logs opruimen, Docker images opschonen).
### Docker logs vluchtig controleren
```bash
cd ~/umami && docker compose logs --since 24h umami
```
Zoek naar foutmeldingen of crashes.
---
## Maandelijks (~30 minuten)
### Systeemupdates installeren
```bash
sudo apt update && apt list --upgradable
sudo apt upgrade -y
```
Herstart daarna de server als de kernel geüpdatet is:
```bash
sudo reboot
```
Controleer na herstart of alle services weer draaien (zie wekelijkse check).
### Umami updaten
```bash
cd ~/umami
docker compose pull
docker compose up -d
```
### Database backup maken
```bash
docker compose exec db pg_dump -U umami umami > \
~/umami/backup-$(date +%Y%m%d).sql
```
Kopieer de backup naar een externe locatie (lokale machine of cloud opslag):
```bash
# Vanaf je lokale machine:
scp deploy@<server-ip>:~/umami/backup-$(date +%Y%m%d).sql ~/backups/
```
Verwijder oude backups op de server (bewaar de laatste 3):
```bash
ls -t ~/umami/backup-*.sql | tail -n +4 | xargs rm -f
```
### SSL-certificaat controleren
```bash
sudo certbot renew --dry-run
```
Dit simuleert vernieuwing zonder het certificaat daadwerkelijk te vervangen. Als het slaagt, is automatische vernieuwing correct ingesteld.
Vervaldatum handmatig inzien:
```bash
sudo certbot certificates
```
### Nginx-logs bekijken op verdacht verkeer
```bash
sudo tail -n 100 /var/log/nginx/access.log
sudo tail -n 50 /var/log/nginx/error.log
```
Veel 404-verzoeken op vreemde paden (bijv. `/wp-admin`, `/.env`) zijn normaal scannerverkeer — fail2ban pakt dit gedeeltelijk af. Bij aanhoudend verkeer van één IP kun je dat handmatig blokkeren:
```bash
sudo ufw deny from <ip-adres>
```
### Docker opschonen
Ongebruikte images en containers stapelen zich op en verbruiken schijfruimte:
```bash
docker system prune -f
```
---
## Kwartaal (~1 uur)
### UTM campagnes updaten
- Voeg nieuwe campagnewaarden toe aan het UTM-scheme (nieuwe kwartaalcodes)
- Archiveer verlopen campagnes in de UTM tracker spreadsheet (status → `archived`)
- Controleer in Umami welke bronnen en campagnes het meest verkeer opleveren
### Wachtwoorden roteren
- Umami admin-wachtwoord wijzigen via **Settings → Profile**
- Overweeg het database-wachtwoord in `docker-compose.yml` te roteren (vereist herstart van de stack)
### Firewall-regels reviewen
```bash
sudo ufw status verbose
```
Verwijder regels die niet meer nodig zijn.
### Serverresources evalueren
```bash
# CPU en geheugen
htop
# Schijfruimte per map
du -sh ~/umami/*
sudo du -sh /var/log/*
```
Bij structureel hoog geheugen- of CPU-gebruik: overweeg een groter Hostinger-pakket.
---
## Bij incidenten
### Service ligt plat
```bash
# Herstart individuele service
sudo systemctl restart nginx
sudo systemctl restart fail2ban
cd ~/umami && docker compose restart
```
### Umami dashboard niet bereikbaar
Controleer in volgorde:
1. Draaien de Docker containers? → `docker compose ps`
2. Luistert Nginx? → `sudo systemctl status nginx`
3. Klopt de DNS? → `dig analytics.iso27diy.com`
4. Is het SSL-certificaat geldig? → `sudo certbot certificates`
### Database herstellen vanuit backup
```bash
cd ~/umami
docker compose stop umami
docker compose exec db psql -U umami -c "DROP DATABASE umami;"
docker compose exec db psql -U umami -c "CREATE DATABASE umami;"
docker compose exec -T db psql -U umami umami < backup-YYYYMMDD.sql
docker compose start umami
```
### Jezelf buitengesloten via fail2ban
Doe dit vanaf een andere internetverbinding (bijv. mobiel):
```bash
sudo fail2ban-client set sshd unbanip <jouw-ip>
```
---
## Handige commando's — spiekbriefje
| Wat | Commando |
|-----|----------|
| Services checken | `sudo systemctl status nginx fail2ban` |
| Docker containers checken | `cd ~/umami && docker compose ps` |
| Schijfruimte | `df -h` |
| fail2ban status | `sudo fail2ban-client status sshd` |
| Umami logs | `cd ~/umami && docker compose logs -f umami` |
| Nginx logs | `sudo tail -n 100 /var/log/nginx/access.log` |
| Database backup | `docker compose exec db pg_dump -U umami umami > backup-$(date +%Y%m%d).sql` |
| Systeem updaten | `sudo apt update && sudo apt upgrade -y` |
| Umami updaten | `cd ~/umami && docker compose pull && docker compose up -d` |
| Docker opschonen | `docker system prune -f` |
| IP blokkeren | `sudo ufw deny from <ip>` |
| IP deblokkeren (fail2ban) | `sudo fail2ban-client set sshd unbanip <ip>` |

449
vps@hostinger/VPS install playbook.md
View file

@ -1,449 +0,0 @@
# Stappenplan: Umami op Hostinger VPS
**Omgeving:** Ubuntu 24.04 LTS · 8 GB RAM · 2 vCPU · 100 GB SSD
**Doel:** Umami analytics bereikbaar op `analytics.iso27diy.com`
---
## Overzicht
1. Server beveiligen (gebruiker, firewall, SSH)
2. Docker installeren
3. Subdomein aanmaken in Netlify DNS
4. Umami deployen met Docker Compose
5. Nginx instellen als reverse proxy
6. SSL certificaat installeren (Let's Encrypt)
7. Tracking script toevoegen aan Netlify site
8. UTM-tracking testen
Geschatte tijd: **45–60 minuten**
---
## Stap 1 — Server beveiligen
### 1.1 Inloggen als root
```bash
ssh root@<jouw-server-ip>
```
### 1.2 Systeem updaten
```bash
apt update && apt upgrade -y
```
### 1.3 Nieuwe gebruiker aanmaken
Werken als root is risicovol. Maak een aparte gebruiker aan:
```bash
adduser deploy
usermod -aG sudo deploy
```
Kies een sterk wachtwoord wanneer daarom gevraagd wordt.
### 1.4 SSH-toegang instellen voor nieuwe gebruiker
```bash
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy
```
Test in een **nieuw terminalvenster** (sluit de huidige sessie nog niet):
```bash
ssh deploy@<jouw-server-ip>
```
Als dat werkt: goed. Sluit nu de root-sessie.
### 1.5 Root-login via SSH uitschakelen
```bash
sudo nano /etc/ssh/sshd_config
```
Zoek de regel `PermitRootLogin yes` en verander die naar:
```
PermitRootLogin no
```
Sla op met `Ctrl+O`, sluit met `Ctrl+X`. Herstart SSH:
```bash
sudo systemctl restart ssh
```
### 1.6 Firewall instellen
```bash
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
```
Controleer de status:
```bash
sudo ufw status
```
Je zou dit moeten zien:
```
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443/tcp ALLOW Anywhere
```
### 1.7 fail2ban installeren
```bash
sudo apt install -y fail2ban
```
Maak een configuratiebestand aan:
```bash
sudo nano /etc/fail2ban/jail.local
```
Plak:
```ini
[DEFAULT]
bantime = 1h
findtime = 10m
maxretry = 5
[sshd]
enabled = true
port = ssh
logpath = %(sshd_log)s
backend = %(sshd_backend)s
```
Activeer en start:
```bash
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
```
Status controleren:
```bash
sudo fail2ban-client status sshd
```
Een gebanned IP handmatig deblokkeren:
```bash
sudo fail2ban-client set sshd unbanip <ip-adres>
```
---
## Stap 2 — Docker installeren
```bash
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
```
Voeg je gebruiker toe aan de docker-groep (zodat je geen `sudo` nodig hebt):
```bash
sudo usermod -aG docker deploy
newgrp docker
```
Test of het werkt:
```bash
docker run hello-world
```
---
## Stap 3 — Subdomein aanmaken in Netlify DNS
Je domein `iso27diy.com` gebruikt Netlify als DNS. Zo voeg je het subdomein toe:
1. Log in op [app.netlify.com](https://app.netlify.com)
2. Ga naar **Domains** (linksboven in het menu)
3. Klik op `iso27diy.com`
4. Klik op **Add new record**
5. Vul in:
- **Type:** `A`
- **Name:** `analytics`
- **Value:** `<jouw-server-ip>` (het IP-adres van je Hostinger VPS)
- **TTL:** laat op standaard staan
1. Klik **Save**
Het DNS-record propageert doorgaans binnen 5–15 minuten. Je kunt het controleren via:
```bash
dig analytics.iso27diy.com
```
Wacht met de volgende stap tot het IP-adres correct terugkomt.
---
## Stap 4 — Umami deployen met Docker Compose
### 4.1 Map aanmaken
```bash
mkdir -p ~/umami && cd ~/umami
```
### 4.2 docker-compose.yml aanmaken
```bash
nano docker-compose.yml
```
Plak de volgende inhoud:
```yaml
version: '3'
services:
umami:
image: ghcr.io/umami-software/umami:postgresql-latest
ports:
- "127.0.0.1:3000:3000"
environment:
DATABASE_URL: postgresql://umami:umami_password@db:5432/umami
DATABASE_TYPE: postgresql
APP_SECRET: vervang_dit_door_een_willekeurige_lange_string
depends_on:
db:
condition: service_healthy
restart: always
db:
image: postgres:15-alpine
environment:
POSTGRES_DB: umami
POSTGRES_USER: umami
POSTGRES_PASSWORD: umami_password
volumes:
- umami-db:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U umami"]
interval: 5s
timeout: 5s
retries: 5
restart: always
volumes:
umami-db:
```
**Belangrijk:** vervang `umami_password` door een sterk wachtwoord, en `vervang_dit_door_een_willekeurige_lange_string` door een willekeurige string (bijv. via `openssl rand -base64 32`).
Genereer een willekeurige APP_SECRET:
```bash
openssl rand -base64 32
```
Kopieer de output en plak die als waarde voor `APP_SECRET`.
Sla op met `Ctrl+O`, sluit met `Ctrl+X`.
### 4.3 Umami starten
```bash
docker compose up -d
```
Controleer of de containers draaien:
```bash
docker compose ps
```
Beide services (`umami` en `db`) moeten de status `running` hebben. Dit kan 1–2 minuten duren bij de eerste start.
Controleer de logs als iets niet klopt:
```bash
docker compose logs -f
```
---
## Stap 5 — Nginx instellen als reverse proxy
Nginx ontvangt het verkeer op poort 80/443 en stuurt het door naar Umami op poort 3000.
### 5.1 Nginx installeren
```bash
sudo apt install -y nginx
```
### 5.2 Configuratie aanmaken
```bash
sudo nano /etc/nginx/sites-available/analytics.iso27diy.com
```
Plak:
```nginx
server {
listen 80;
server_name analytics.iso27diy.com;
location / {
proxy_pass http://127.0.0.1:3000;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_cache_bypass $http_upgrade;
}
}
```
Sla op en sluit.
### 5.3 Configuratie activeren
```bash
sudo ln -s /etc/nginx/sites-available/analytics.iso27diy.com \
/etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```
`nginx -t` moet `syntax is ok` teruggeven.
---
## Stap 6 — SSL certificaat installeren
```bash
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d analytics.iso27diy.com
```
Certbot vraagt om een e-mailadres en of je akkoord gaat met de voorwaarden. Na afloop past het de Nginx-configuratie automatisch aan voor HTTPS en regelt het automatische verlenging.
Controleer automatische verlenging:
```bash
sudo certbot renew --dry-run
```
---
## Stap 7 — Eerste login en wachtwoord wijzigen
Ga naar `https://analytics.iso27diy.com` in je browser.
- **Gebruikersnaam:** `admin`
- **Wachtwoord:** `umami`
Ga direct naar **Settings → Profile** en stel een sterk wachtwoord in.
### Website toevoegen
1. Ga naar **Settings → Websites → Add website**
2. Vul in:
- **Name:** iso27diy.com
- **Domain:** iso27diy.com
3. Klik **Save**
4. Klik op het **tracking code** icoontje naast de website om je `data-website-id` te kopiëren
---
## Stap 8 — Tracking script toevoegen aan Netlify site
Voeg dit toe aan de `<head>` van je site. Hoe je dat doet hangt af van hoe je site gebouwd is, maar in de meeste gevallen is er een hoofd-HTML-template.
```html
<script
defer
src="https://analytics.iso27diy.com/script.js"
data-website-id="jouw-website-id-hier"
data-domains="iso27diy.com">
</script>
```
Het `data-domains` attribuut zorgt dat bezoeken vanaf andere domeinen (zoals localhost tijdens ontwikkeling) niet meegeteld worden.
Na een Netlify deploy: ga naar je site, wacht een paar seconden, en controleer of er een bezoek verschijnt in het Umami dashboard onder **Realtime**.
---
## Stap 9 — UTM-tracking testen
Maak een test-URL met UTM-parameters:
```
https://iso27diy.com/?utm_source=linkedin&utm_medium=post&utm_campaign=test&utm_content=cta-hero
```
Bezoek die URL in een browser. Ga dan in Umami naar:
**Reports → UTM** (of in het hoofddashboard onder **Sources**)
Je ziet daar de uitsplitsing per `source`, `medium`, `campaign` en `content`.
---
## Updates uitvoeren
Umami brengt regelmatig updates uit. Updaten gaat zo:
```bash
cd ~/umami
docker compose pull
docker compose up -d
```
---
## Database backup
Railway maakte geen automatische backups — op je eigen VPS ook niet, tenzij je dat instelt. Maak periodiek een handmatige backup:
```bash
docker compose exec db pg_dump -U umami umami > \
~/umami/backup-$(date +%Y%m%d).sql
```
Bewaar backups op een andere locatie (bijv. je lokale machine of een cloud opslag).
---
## Samenvatting gebruikte poorten en services
| Service | Poort | Bereikbaar vanaf |
| --------------- | ------- | -------------------- |
| Nginx | 80, 443 | Internet |
| Umami (Node.js) | 3000 | Alleen localhost |
| PostgreSQL | 5432 | Alleen Docker intern |

24
vps@hostinger/VPS security.md
View file

@ -1,24 +0,0 @@
# VPS Beveiligingsmaatregelen
### Server hardening
- Root SSH-login uitgeschakeld
- Dedicated non-root gebruiker (`deploy`) met sudo-rechten
- SSH key authenticatie
- UFW firewall — alleen poorten 22, 80 en 443 open
- fail2ban actief — IP-adressen worden 1 uur geblokkeerd na 5 mislukte SSH-pogingen binnen 10 minuten
### Netwerk & encryptie
- HTTPS afgedwongen via Nginx + Let's Encrypt
- Umami gebonden aan `127.0.0.1` — niet publiek bereikbaar
- PostgreSQL alleen op intern Docker-netwerk
- SSL automatisch vernieuwd via Certbot
### Applicatiebeveiliging
- Umami standaardwachtwoord direct wijzigen bij eerste login
- `APP_SECRET` gerandomiseerd met `openssl rand -base64 32`
- Cookieloze tracking — geen persoonsgegevens opgeslagen
- `data-domains` attribuut beperkt tracking tot productiedomein
### Nog te doen
- [ ] Periodieke database backups instellen (cronjob) — een cronjob op de VPS die dagelijks een dump maakt en bijv. naar je lokale machine of een object storage stuurt. Nu verlies je bij een VPS-crash alles wat na je laatste handmatige backup binnenkomt.
- [ ] fail2ban installeren voor SSH brute-force bescherming — blokkeert automatisch IP-adressen die te vaak fout inloggen via SSH. Eén commando om te installeren, vrijwel geen configuratie nodig.

28
vps@hostinger/VPS specs.md
View file

@ -1,28 +0,0 @@
# VPS configuratie
- srv1119777.hstgr.cloud
- ssh root@72.61.188.15
- IPv4: 72.61.188.15
- IPv6: 2a02:4780:41:a7e5::1
* Plan: KVM 2 VPS, datacenter Frankfurt (DE), Verloopt op 2027-12-04
* OS: Ubuntu 24.04 LTS
* Resources: 8 GB RAM, 2 vCPU, 100 GB SSD (≈ 2.8 GB used), bandwidth 8 TB/maand (≈ 0.01% used)
* Back-ups: Automatische dagelijkse back-up: **uitgeschakeld**
## Samenvatting gebruikte poorten en services
per 10 April 2026
| Service | Poort | Bereikbaar vanaf |
| --------------- | ------- | -------------------- |
| Nginx | 80, 443 | Internet |
| Umami (Node.js) | 3000 | Alleen localhost |
| PostgreSQL | 5432 | Alleen Docker intern |
Docker draait ook, natuurlijk
- [ ] regelmatig updates en backups draaien
- [ ] logs draaien voor afwijkingen
## Samenvatting 11 april 2026

18
vps@hostinger/VPS stack.md
View file

@ -1,18 +0,0 @@
# VPS Infrastructure stack
per 11 April 2026
| Component | Details | Platform |
|-----------|---------|----------|
| Website hosting | iso27diy.com — statische site | Netlify |
| DNS | iso27diy.com + analytics.iso27diy.com | Netlify DNS |
| Domeinregistrar | iso27diy.com gekocht hier | Hover |
| VPS | Ubuntu 24.04 · 8 GB RAM · 2 vCPU · 100 GB SSD | Hostinger |
| Analytics app | analytics.iso27diy.com · poort 3000 (intern) | Umami |
| Database | PostgreSQL 15 · alleen Docker intern netwerk | Docker |
| Reverse proxy | Handelt HTTPS af, stuurt door naar Umami op :3000 | Nginx |
| SSL | Automatisch vernieuwd · analytics.iso27diy.com | Let's Encrypt |
| fail2ban | SSH brute-force bescherming | Hostinger VPS |
---
[VPS security](VPS%20security.md)