| Vereisten
- Een Ubuntu 20.04-server met een niet-rootgebruiker met `sudo`-rechten.
- Een Kubernetes-cluster geïnstalleerd op de server, zoals `kubeadm`, `k3s`, `minikube`, `Rancher`, enz.
- Toegang tot het opdrachtregel-/terminalvenster.
Stap 1:Update het systeem
Werk uw pakketlijsten bij voordat u doorgaat met installaties:
```sch
sudo apt update &&sudo apt upgrade -y
```
Stap 2:Voeg Kong Kong Gateway Repository toe
Importeer de GPG-sleutel voor de Kubernetes-repository, waarmee u de uitgever van het pakket kunt identificeren.
```sch
krul https://download.konghq.com/keyring/kong.gpg | sudo apt-key toevoegen -
```
Creëer de Kong-repositorylijst zodat apt Kong van de officiële bron kan verkrijgen.
```sch
echo "deb [arch=amd64] https://download.konghq.com/deb stable main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Stap 3:Kong Gateway installeren
Installeer nu Kong Gateway met behulp van de standaard pakketbeheerder, apt.
```sch
sudo apt installeer kong
```
Met deze opdracht moet Kong Gateway en al zijn afhankelijkheden worden geïnstalleerd.
Stap 4:Kong-service inschakelen en controleren
Zodra de installatie is voltooid, voert u de volgende opdracht uit om de Kong-service in te schakelen:
```sch
sudo systemctl schakel kong in
```
En start dan de Kong-service:
```sch
sudo systemctl start kong
```
Gebruik de volgende opdracht om te controleren of de Kong-service actief is:
```sch
sudo systemctl status kong
```
Stap 5:Installeer de Ingress-controller
Vervolgens installeren we de Kong Ingress Controller, die fungeert als brug tussen Kong Gateway en Kubernetes.
Voer de volgende opdracht uit om de Kong Ingress Controller te installeren met behulp van Helm, de Kubernetes-pakketbeheerder:
```sch
helm repo add kong https://charts.konghq.com
helm repo-update
helm install kong/kong-ingress-controller --namespace=kong --create-namespace
```
Hiermee wordt Kong Ingress Controller geïnstalleerd in een nieuw gemaakte `kong`-naamruimte.
Stap 6:Externe verkeerstoegang tot Kong Gateway configureren
Standaard luistert Kong Gateway naar verzoeken op de lokale interface en poort 8000. Om externe toegang van buiten uw server mogelijk te maken, zoals vanaf de clients in uw cluster, moeten we het netwerkbeleid van Kubernetes configureren.
Maak het benodigde netwerkbeleid met `kubectl`:
```sch
kubectl create -f - <
apiVersie:network.k8s.io/v1
soort:Netwerkbeleid
metagegevens:
naam:allow-verkeer
specificatie:
podSelector:{}
binnenkomen:
- van:
- naamruimteSelector:
matchLabels:
naam:kong
poorten:
- poort:8000
protocol:TCP
EOF
```
Met dit netwerkbeleid kunnen alle pods in de 'kong'-naamruimte verkeer naar Kong Gateway sturen.
Stap 7:De Kong Gateway testen
Om te testen of Kong Gateway naar verwachting werkt, kunt u er een verzoek naar sturen. Voer de volgende opdracht uit om een HTTP-verzoek te verzenden met `curl`.
```sch
curl -IL http://localhost:8000
```
U zou een HTTP 404-antwoord moeten ontvangen, wat aangeeft dat Kong Gateway het verzoek ontvangt, maar dat er geen overeenkomende routes of services beschikbaar zijn.
Stap 8:Integratie met Kubernetes Services
Om de installatie te voltooien, kunt u een eenvoudige applicatie in uw Kubernetes-cluster implementeren en Kong Gateway gebruiken als ingangscontroller om verzoeken naar de applicatie te routeren.
Hier is een voorbeeld van een `Deployment`-manifest voor een eenvoudige applicatie met de naam `nginx`:
```jaml
apiVersie:apps/v1
soort:implementatie
metagegevens:
naam:nginx
etiketten:
app:nginx
specificatie:
keuzeschakelaar:
matchLabels:
app:nginx
replica's:1
sjabloon:
metagegevens:
etiketten:
app:nginx
specificatie:
containers:
- naam:nginx
afbeelding:nginx:1.21
poorten:
- containerhaven:80
naam:http
```
Sla het op in een bestand met de naam `nginx.yaml`. Implementeer het vervolgens in uw Kubernetes-cluster:
```sch
kubectl pas -f nginx.yaml toe
```
Hierdoor ontstaat een implementatie voor een eenvoudige Nginx-server.
#### De dienst creëren
Maak vervolgens een Kubernetes-service die poort 80 van alle peulen met het label `app=nginx` openbaar maakt:
```jaml
apiVersie:v1
soort:Dienst
metagegevens:
naam:nginx
etiketten:
app:nginx
specificatie:
poorten:
- poort:80
naam:http
keuzeschakelaar:
app:nginx
```
Sla het op in een bestand met de naam `nginx-service.yaml`. Implementeer het vervolgens in uw Kubernetes-cluster:
```sch
kubectl pas -f nginx-service.yaml toe
```
#### De KongRoute maken
Configureer ten slotte Kong Gateway om verkeer naar onze `nginx`-service te leiden. Hieronder ziet u een voorbeeldmanifest voor een KongRoute:
```jaml
apiVersie:konghq.com/v1
soort:KongRoute
metagegevens:
naam:voorbeeld
specificatie:
protocollen:
- https
host:voorbeeld.com
paden:
- /
dienst:
naam:nginx-kong
poort:80
protocol:http
```
Sla dit manifest op in een bestand met de naam `example-route.yaml` en pas het toe op uw Kubernetes-cluster:
```sch
kubectl pas -f voorbeeld-route.yaml toe
```
Hierdoor wordt een configuratie gemaakt, die Kong Gateway vertelt HTTPS-verzoeken naar het domein `example.com` te accepteren en deze door te sturen naar onze `nginx`-service die op poort 80 draait met behulp van HTTP.
Route testen
Nu kunt u de Kong Gateway-routering testen. Voer vanaf elke machine met toegang tot het Kubernetes-cluster het volgende uit:
```sch
curl -k https://example.com
```
Als alles correct is ingesteld, zou u de standaard Nginx-welkomstpagina moeten zien.
Gefeliciteerd! U hebt Kong Gateway op Ubuntu Linux geïnstalleerd, de Ingress-controller ingesteld, netwerkbeleid geconfigureerd en de routering naar een toepassing in uw Kubernetes-cluster getest. |
