Translation/dutch759 766 767 (#779)

docs/deploy/digital-ocean.nl.md

@@ -8,12 +8,12 @@ Laten we beginnen met het installeren van Swift op een Linux server. Gebruik het
 
 ![Create Droplet](../images/digital-ocean-create-droplet.png)
 
-Onder distributies, selecteer Ubuntu 18.04 LTS. De volgende gids zal deze versie als voorbeeld gebruiken.
+Onder distributies, selecteer Ubuntu 22.04 LTS. De volgende gids zal deze versie als voorbeeld gebruiken.
 
 ![Ubuntu Distro](../images/digital-ocean-distributions-ubuntu.png)
 
 !!! note  "Opmerking"
-	U kunt elke Linux distributie kiezen met een versie die Swift ondersteunt. Op het moment van schrijven ondersteunt Swift 5.2.4 Ubuntu 16.04, 18.04, 20.04, CentOS 8, en Amazon Linux 2. U kunt controleren welke besturingssystemen officieel worden ondersteund op de [Swift Releases](https://swift.org/download/#releases) pagina.
+	U kunt elke Linux distributie kiezen met een versie die Swift ondersteunt. Op het moment van schrijven ondersteunt Swift 5.7.3 Ubuntu 18.04, 20.04, 22.04, CentOS 7, en Amazon Linux 2. U kunt controleren welke besturingssystemen officieel worden ondersteund op de [Swift Releases](https://swift.org/download/#releases) pagina.
 
 Na het selecteren van de distributie, kies een plan en datacenter regio van uw voorkeur. Stel dan een SSH sleutel in om toegang te krijgen tot de server nadat deze is aangemaakt. Klik tenslotte op Droplet aanmaken en wacht tot de nieuwe server is opgestart.
 
@@ -29,7 +29,7 @@ Open uw terminal en maak verbinding met de server als root met SSH.
 ssh root@your_server_ip
 ```
 
-DigitalOcean heeft een diepgaande gids voor [initiële serverinstallatie op Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04). Deze gids zal snel de basis behandelen.
+DigitalOcean heeft een diepgaande gids voor [initiële serverinstallatie op Ubuntu 22.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-22-04). Deze gids zal snel de basis behandelen.
 
 ### Configureer Firewall
 
@@ -77,38 +77,40 @@ Installeer de vereiste afhankelijkheden van Swift.
 
 ```sh
 sudo apt-get update
-sudo apt-get install clang libicu-dev libatomic1 build-essential pkg-config
+sudo apt-get install binutils git gnupg2 libc6-dev libcurl4-openssl-dev 
+ 	\ libedit2 libgcc-9-dev libpython3.8 libsqlite3-0 libstdc++-9-dev 
+ 	\ libxml2-dev libz3-dev pkg-config tzdata unzip zlib1g-dev
 ```
 
-### Toolchain Downloaden
+### Swift Toolchain Downloaden
 
-Deze handleiding installeert Swift 5.2.4. Bezoek de [Swift Releases](https://swift.org/download/#releases) pagina voor een link naar de laatste release. Kopieer de download link voor Ubuntu 18.04.
+Deze handleiding installeert Swift 5.7.3. Bezoek de [Swift Releases](https://swift.org/download/#releases) pagina voor een link naar de laatste release. Kopieer de download link voor Ubuntu 22.04.
 
 ![Download Swift](../images/swift-download-ubuntu-copy-link.png)
 
 Download en decomprimeer de Swift toolchain.
 
 ```sh
-wget https://swift.org/builds/swift-5.2.4-release/ubuntu1804/swift-5.2.4-RELEASE/swift-5.2.4-RELEASE-ubuntu18.04.tar.gz
+wget https://download.swift.org/swift-5.7.3-release/ubuntu2204/swift-5.7.3-RELEASE/swift-5.7.3-RELEASE-ubuntu22.04.tar.gz
-tar xzf swift-5.2.4-RELEASE-ubuntu18.04.tar.gz
+tar xzf swift-5.7.3-RELEASE-ubuntu22.04.tar.gz
 ```
 
 !!! note "Opmerking"
 	Swift's [Downloads gebruiken](https://swift.org/download/#using-downloads) gids bevat informatie over hoe downloads te verifiëren met PGP-handtekeningen.
 
-### Installeer Toolchain
+### Installeer Swift Toolchain
 
 Zet Swift ergens waar het makkelijk toegankelijk is. Deze gids zal `/swift` gebruiken met elke compiler versie in een submap. 
 
 ```sh
 sudo mkdir /swift
-sudo mv swift-5.2.4-RELEASE-ubuntu18.04 /swift/5.2.4
+sudo mv swift-5.7.3-RELEASE-ubuntu22.04 /swift/5.7.3
 ```
 
 Voeg Swift toe aan `/usr/bin` zodat het kan worden uitgevoerd door `vapor` en `root`.
 
 ```sh
-sudo ln -s /swift/5.2.4/usr/bin/swift /usr/bin/swift
+sudo ln -s /swift/5.7.3/usr/bin/swift /usr/bin/swift
 ```
 
 Controleer of Swift correct is geïnstalleerd.
@@ -117,49 +119,68 @@ Controleer of Swift correct is geïnstalleerd.
 swift --version
 ```
 
-## Opzet Project
+## Installeer Vapor met de Vapor Toolbox
 
-Nu Swift geïnstalleerd is, laten we je project klonen en compileren. Voor dit voorbeeld zullen we gebruik maken van Vapor's [API sjabloon](https://github.com/vapor/api-template/).
+Nu Swift geïnstalleerd is, laten we Vapor installeren door de Vapor Toolbox te gebruiken. U moet via de broncode de toolbox bouwen. Bekijk de toolbox [releases](https://github.com/vapor/toolbox/releases) op Github om de laatste versie te vinden. In dit voorbeeld gebruiken we versie 18.6.0.
 
-Laten we eerst de systeemafhankelijkheden van Vapor installeren.
+### Clone & Build Vapor
 
+Kloon de Vapor Toolbox repository
 ```sh
-sudo apt-get install openssl libssl-dev zlib1g-dev libsqlite3-dev
+git clone https://github.com/vapor/toolbox.git
 ```
 
-Sta HTTP toe door de firewall.
+Haal de laatste release op.
 
 ```sh
-sudo ufw allow http
+cd toolbox
+git checkout 18.6.0
 ```
 
-### Clone & Build
+Bouw Vapor en verplaats de binary in je pad.
-
-Kloon nu het project en bouw het.
 
 ```sh
-git clone https://github.com/vapor/api-template.git
+swift build -c release --disable-sandbox --enable-test-discovery
-cd api-template
+sudo mv .build/release/vapor /usr/local/bin
-swift build
+```
+
+### Maak een Vapor Project
+
+Gebruik het `new` commando van de Toolbox om een nieuw project aan te maken
+
+```sh
+vapor new HelloWorld -n
 ```
 
 !!! tip
-	Als u dit project bouwt voor productie, gebruik dan `swift build -c release`.
+	De `-n` vlag geeft je een barebones sjabloon door automatisch nee te antwoorden op alle vragen
+
+![Vapor Splash](../images/vapor-splash.png)
+
+Eens het commando gedaan is kan je naar de nieuw gemaakte folder gaan:
+
+```sh
+cd HelloWorld
+```
+
+### Open HTTP Port
+
+Om je Vapor applicatie te kunnen gebruiken, moet je een HTTP poort openzetten.
+
+```sh
+sudo ufw allow 8080
+```
 
 ### Run
 
-Once the project has finished compiling, run it on your server's IP at port 80. The IP address is `157.245.244.228` in this example.
+Nu dat Vapor klaar is en we een open poort hebben, laten we het commando runnen.
 
 ```sh
-sudo .build/debug/Run serve -b 157.245.244.228:80
+vapor run serve --hostname 0.0.0.0 --port 8080
 ```
 
-Als u `swift build -c release` heeft gebruikt, dan moet u volgend commando uitvoeren:
+Bezoek de IP van uw server via een browser of lokale terminal en u zou moeten zien "It works!". Het IP address in dit voorbeeld is `134.122.126.139`.
-```sh
-sudo .build/release/Run serve -b 157.245.244.228:80
-```
 
-Bezoek de IP van uw server via een browser of lokale terminal en u zou moeten zien "It works!".
 ```
 $ curl http://157.245.244.228
 It works!
@@ -168,7 +189,7 @@ It works!
 Terug op je server, zou je logs moeten zien voor het test verzoek.
 
 ```
-[ NOTICE ] Server starting on http://157.245.244.228:80
+[ NOTICE ] Server starting on http://0.0.0.0:8080
 [ INFO ] GET /
 ```
 

docs/deploy/fly.nl.md

@@ -0,0 +1,181 @@
+# Fly
+
+Fly is een hosting platform waar U server applicaties en databases kunnen laten draaien met een focus op edge computing. Zie [hun website](https://fly.io/) voor meer informatie.
+
+!!! opmerking
+    De in dit document gespecificeerde commando's zijn onderworpen aan [Fly's pricing](https://fly.io/docs/about/pricing/), zorg ervoor dat u deze goed begrijpt voordat u verder gaat.
+
+## Registreren
+Als je nog geen account heb, dan zal je er [een moeten maken](https://fly.io/app/sign-up).
+
+## Installeren van flyctl
+De belangrijkste manier om met Fly te communiceren is met het bijbehorende CLI-programma, `flyctl`, dat je moet installeren.
+
+### macOS
+```bash
+brew install flyctl
+```
+
+### Linux
+```bash
+curl -L https://fly.io/install.sh | sh
+```
+
+### Andere installatiemogelijkheden
+Voor meer opties en details, zie [de `flyctl` installatie docs](https://fly.io/docs/hands-on/install-flyctl/).
+
+## Aanmelden
+Om aan te melden vanuit je terminal, voer je het volgende commando uit:
+```bash
+fly auth login
+```
+
+## Je Vapor project configureren
+Alvorens te deployen naar Fly, moet u ervoor zorgen dat u een Vapor-project heeft met een correct geconfigureerd Dockerbestand, aangezien Fly dit nodig heeft om uw app te bouwen. In de meeste gevallen zou dit heel eenvoudig moeten zijn, omdat de standaard Vapor-sjablonen er al een bevatten.
+
+### Nieuw Vapor project
+De eenvoudigste manier om een nieuw project te maken is te beginnen met een sjabloon. U kunt er een maken met behulp van GitHub-sjablonen of de Vapor-toolbox. Als u een database nodig hebt, is het aanbevolen om Fluent met Postgres te gebruiken; Fly maakt het eenvoudig om een Postgres-database aan te maken om uw apps mee te verbinden (zie de [specifieke sectie](#configuratie-postgres) hieronder).
+
+#### De Vapor toolbox gebruiken
+Zorg er eerst voor dat je de Vapor toolbox hebt geïnstalleerd (zie de instructies voor [macOS](../install/macos.md#install-toolbox) of [Linux](../install/linux.md#install-toolbox)).
+Maak uw nieuwe app aan met het volgende commando, waarbij u `app-name` vervangt door de gewenste app-naam:
+
+```bash
+vapor new app-name
+```
+
+Dit commando toont een interactieve prompt waarmee u uw Vapor-project kunt configureren, hier kunt u Fluent en Postgres selecteren als u die nodig hebt.
+
+#### De GitHub sjablonen gebruiken
+Kies in de volgende lijst het sjabloon dat het beste bij uw behoeften past. Je kunt het lokaal klonen met Git of een GitHub-project aanmaken met de knop "Gebruik dit sjabloon".
+
+- [Barebones template](https://github.com/vapor/template-bare)
+- [Fluent/Postgres template](https://github.com/vapor/template-fluent-postgres)
+- [Fluent/Postgres + Leaf template](https://github.com/vapor/template-fluent-postgres-leaf)
+
+### Bestaand Vapor project
+Als je een bestaand Vapor-project hebt, zorg er dan voor dat je een goed geconfigureerde `Dockerfile` in de root van je map hebt staan; de [Vapor docs over het gebruik van Docker](../deploy/docker.md) en [Fly docs over het deployen van een app via een Dockerfile](https://fly.io/docs/getting-started/dockerfile/) kunnen van pas komen.
+
+## Start uw app op Fly
+Zodra uw Vapor-project klaar is, kunt u het lanceren op Fly.
+
+Zorg er eerst voor dat je huidige map is ingesteld op de hoofdmap van je Vapor-toepassing en voer het volgende commando uit:
+```bash
+fly launch
+```
+
+Dit start een interactieve prompt om de instellingen van uw Fly-toepassing te configureren:
+
+- **Name:** u kunt er een typen of leeg laten om een automatisch gegenereerde naam te krijgen.
+- **Region:** standaard is dit degene die het dichtst bij u staat. U kunt kiezen om die te gebruiken of een andere in de lijst. Dit is later gemakkelijk te veranderen.
+- **Database:** u kunt Fly vragen om een database aan te maken voor gebruik met uw app. Als u dat liever zelf doet, kunt u later altijd hetzelfde doen met de `fly pg create` en `fly pg attach` commando's (zie de [Configuratie van Postgres sectie](#configuratie-postgres) voor meer details).
+
+Het `fly launch` commando maakt automatisch een `fly.toml` bestand aan. Het bevat instellingen zoals private/publieke port mappings, health check parameters, en vele andere. Als je net een nieuw project hebt gemaakt met `vapor new`, hoeft het standaard `fly.toml` bestand niet gewijzigd te worden. Als je een bestaand project hebt, is de kans groot dat `fly.toml` ook in orde is met geen of kleine wijzigingen. U kunt meer informatie vinden in de [`fly.toml` documentatie](https://fly.io/docs/reference/configuration/).
+
+Merk op dat als u Fly vraagt om een database aan te maken, u even moet wachten tot deze is aangemaakt en de health checks geslaagd zijn.
+
+Voor het afsluiten zal het `fly launch` commando je vragen of je je app onmiddellijk wilt deployen. Je kunt dit accepteren of het later doen met `fly deploy`.
+
+!!! tip
+    Wanneer je huidige directory zich in de root van je app bevindt, detecteert de fly CLI tool automatisch de aanwezigheid van een `fly.toml` bestand dat Fly laat weten op welke app je commando's zich richten. Als je een specifieke app wilt gebruiken, ongeacht je huidige directory, kun je `-a naam-van-je-app` toevoegen aan de meeste Fly commando's.
+
+## Deployen
+U voert het `fly deploy` commando uit wanneer u nieuwe wijzigingen in Fly wilt toepassen.
+
+Fly leest de `Dockerfile` en `fly.toml` bestanden van uw directory om te bepalen hoe uw Vapor project gebouwd en uitgevoerd moet worden.
+
+Zodra uw container is gebouwd, start Fly een instantie ervan. Het zal verschillende health checks uitvoeren, om ervoor te zorgen dat uw applicatie goed draait en uw server reageert op verzoeken. Het `fly deploy` commando sluit af met een foutmelding als de gezondheidscontroles mislukken.
+
+Standaard zal Fly teruggaan naar de laatste werkende versie van uw app als de health checks falen voor de nieuwe versie die u probeerde te implementeren.
+
+## Configuratie Postgres
+
+### Een Postgres database aanmaken op Fly
+Als u geen database-app hebt gemaakt toen u uw app voor het eerst lanceerde, kunt u dat later doen met:
+```bash
+fly pg create
+```
+
+Dit commando creëert een Fly app die databases kan hosten die beschikbaar zijn voor uw andere apps op Fly, zie de [toegewijde Fly documentatie](https://fly.io/docs/reference/postgres/) voor meer details.
+
+Zodra uw database-app is gemaakt, gaat u naar de hoofdmap van uw Vapor-app en voert u dit commando uit:
+```bash
+fly pg attach name-of-your-postgres-app
+```
+Als je de naam van je Postgres app niet weet, kun je hem vinden met `fly pg list`.
+
+Het `fly pg attach` commando maakt een database en gebruiker aan die bestemd zijn voor je app, en stelt deze vervolgens bloot aan je app via de `DATABASE_URL` omgevingsvariabele.
+
+!!! opmerking
+    Het verschil tussen `fly pg create` en `fly pg attach` is dat de eerste een Fly app toewijst en configureert die Postgres databases zal kunnen hosten, terwijl de tweede een eigenlijke database en gebruiker aanmaakt die bestemd is voor de app van uw keuze. Als het aan uw eisen voldoet, kan een enkele Postgres Fly app meerdere databases hosten die door verschillende apps worden gebruikt. Wanneer je Fly vraagt om een database app aan te maken in `fly launch`, doet het het equivalent van het aanroepen van zowel `fly pg create` als `fly pg attach`.
+
+### Je Vapor app verbinden met de database
+Zodra uw app is gekoppeld aan uw database, stelt Fly de `DATABASE_URL` omgevingsvariabele in op de verbindings URL die uw referenties bevat (het moet worden behandeld als gevoelige informatie).
+
+Bij de meeste gebruikelijke Vapor project setups, configureer je je database in `configure.swift`. Dit is hoe je dit zou kunnen doen:
+
+```swift
+if let databaseURL = Environment.get("DATABASE_URL") {
+    try app.databases.use(.postgres(url: databaseURL), as: .psql)
+} else {
+    // Handel ontbrekende DATABASE_URL hier af...
+    //
+    // Als alternatief kunt u ook een andere configuratie instellen 
+    // afhankelijk van of app.environment is ingesteld op 
+    // `.development` of `.production`
+}
+```
+
+Op dit punt zou je project klaar moeten zijn om migraties uit te voeren en de database te gebruiken.
+
+### Migraties uitvoeren
+Met `fly.toml`'s `release_command` kun je Fly vragen om een bepaald commando uit te voeren voordat je je hoofdserverproces uitvoert. Voeg dit toe aan `fly.toml`:
+```toml
+[deploy]
+ release_command = "migrate -y"
+```
+
+!!! opmerking
+    De bovenstaande code snippet gaat ervan uit dat je de standaard Vapor Dockerfile gebruikt die je app `ENTRYPOINT` op `./Run` zet. Concreet betekent dit dat wanneer je `release_command` instelt op `migrate -y`, Fly `./Run migrate -y` zal aanroepen. Als je `ENTRYPOINT` op een andere waarde is ingesteld, moet je de waarde van `release_command` aanpassen.
+
+Fly zal uw release commando uitvoeren in een tijdelijke instantie die toegang heeft tot uw interne Fly netwerk, geheimen en omgevingsvariabelen.
+
+Als uw release commando mislukt, zal de deployment niet doorgaan.
+
+### Andere databases
+Hoewel Fly het gemakkelijk maakt om een Postgres database app te maken, is het ook mogelijk om andere soorten databases te hosten (zie bijvoorbeeld ["Gebruik een MySQL database"](https://fly.io/docs/app-guides/mysql-on-fly/) in de Fly documentatie).
+
+## Secrets en omgevingsvariabelen
+### Secrets
+Gebruik geheimen om gevoelige waarden in te stellen als omgevingsvariabelen.
+```bash
+ fly secrets set MYSECRET=A_SUPER_SECRET_VALUE
+```
+
+!!! warning "Waarschuwing"
+    Onthoud dat de meeste shells een geschiedenis bijhouden van de commando's die je getypt hebt. Wees hier voorzichtig mee als je op deze manier geheimen instelt. Sommige shells kunnen geconfigureerd worden om commando's die voorafgegaan worden door een spatie niet te onthouden. Zie ook het [`fly secrets import` commando](https://fly.io/docs/flyctl/secrets-import/).
+
+Voor meer informatie, bekijk de [documentatie van `fly secrets`](https://fly.io/docs/reference/secrets/).
+
+### Omgevingsvariabelen
+U kunt andere niet-gevoelige [omgevingsvariabelen instellen in `fly.toml`](https://fly.io/docs/reference/configuration/#the-env-variables-section), bijvoorbeeld:
+```toml
+[env]
+  MAX_API_RETRY_COUNT = "3"
+  SMS_LOG_LEVEL = "error"
+```
+
+## SSH connectie
+U kunt verbinding maken met de instanties van een app met behulp van:
+```bash
+fly ssh console -s
+```
+
+## De logs controleren
+U kunt de live logs van uw app controleren met:
+```bash
+fly logs
+```
+
+## Volgende stappen
+Nu uw Vapor-app is uitgerold, kunt u nog veel meer doen, zoals uw apps verticaal en horizontaal schalen over meerdere regio's, persistente volumes toevoegen, continuous deployment opzetten of zelfs gedistribueerde app-clusters maken. De beste plaats om te leren hoe u dit alles en nog veel meer kunt doen is de [Fly docs](https://fly.io/docs/).

docs/security/authentication.nl.md

@@ -748,6 +748,9 @@ Deze middlewares doen het volgende:
 * de sessies middleware neemt de sessie cookie uit het verzoek en converteert het in een sessie
 * de sessie-authenticator neemt de sessie en kijkt of er een geauthenticeerde gebruiker voor die sessie is. Zo ja, dan authenticeert de middleware het verzoek. In het antwoord kijkt de sessie-authenticator of het verzoek een geauthenticeerde gebruiker heeft en slaat die op in de sessie, zodat hij bij het volgende verzoek geauthenticeerd is.
 
+!!! opmerking
+    De sessie cookie is niet standaard ingesteld op `secure` en `httpOnly`. Raadpleeg Vapor's [Session API](../advanced/sessions.md#configuration) voor meer informatie over het configureren van cookies.
+
 ### Routes Beschermen
 
 Bij het beveiligen van routes voor een API, retourneer je traditioneel een HTTP antwoord met een status code zoals **401 Unauthorized** als het verzoek niet is geauthenticeerd. Dit is echter geen goede gebruikerservaring voor iemand die een browser gebruikt. Vapor biedt een `RedirectMiddleware` voor elk `Authenticatable` type om te gebruiken in dit scenario: