Förutsättningar
- En Ubuntu 20.04-server med en icke-root-användare med "sudo"-privilegier.
- Ett Kubernetes-kluster installerat på servern, som "kubeadm", "k3s", "minikube", "Rancher", etc.
- Åtkomst till kommandoraden/terminalfönstret.
Steg 1:Uppdatera systemet
Uppdatera dina paketlistor innan du fortsätter med några installationer:
``` sh
sudo apt update &&sudo apt upgrade -y
```
Steg 2:Lägg till Kong Kong Gateway Repository
Importera GPG-nyckeln för Kubernetes-förvaret, vilket hjälper till att identifiera paketets utgivare.
``` sh
curl https://download.konghq.com/keyring/kong.gpg | sudo apt-key add -
```
Skapa Kongs förvarslista så att apt kan hämta Kong från den officiella källan.
``` sh
echo "deb [arch=amd64] https://download.konghq.com/deb stabil main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Steg 3:Installera Kong Gateway
Installera nu Kong Gateway med standardpakethanteraren, apt.
``` sh
sudo apt installera kong
```
Detta kommando bör installera Kong Gateway och alla dess beroenden.
Steg 4:Aktivera och kontrollera Kong Service
När installationen är klar, kör följande kommando för att aktivera Kong-tjänsten:
``` sh
sudo systemctl aktivera kong
```
Och starta sedan Kong-tjänsten:
``` sh
sudo systemctl starta kong
```
För att verifiera om Kong-tjänsten körs, använd följande kommando:
``` sh
sudo systemctl status kong
```
Steg 5:Installera Ingress Controller
Därefter installerar vi Kong Ingress Controller, som fungerar som en bro mellan Kong Gateway och Kubernetes.
Kör följande kommando för att installera Kong Ingress Controller med Helm, Kubernetes pakethanterare:
``` sh
helm repo lägg till kong https://charts.konghq.com
uppdatering av ror repo
helm installera kong/kong-ingress-controller --namespace=kong --create-namespace
```
Detta installerar Kong Ingress Controller i ett nyskapat `kong` namnområde.
Steg 6:Konfigurera extern trafikåtkomst till Kong Gateway
Som standard lyssnar Kong Gateway efter förfrågningar på det lokala gränssnittet och port 8000. För att tillåta fjärråtkomst från utanför din server, till exempel från klienterna i ditt kluster, måste vi konfigurera Kubernetes nätverkspolicyer.
Skapa den nödvändiga nätverkspolicyn med "kubectl":
``` sh
kubectl skapa -f - <
apiVersion:networking.k8s.io/v1
typ:NetworkPolicy
metadata:
namn:tillåt-trafik
spec:
podSelector:{}
inträde:
- från:
- namespace Selector:
matchetiketter:
namn:kong
hamnar:
- port:8000
protokoll:TCP
EOF
```
Denna nätverkspolicy tillåter alla pods i `kong`-namnområdet att skicka trafik till Kong Gateway.
Steg 7:Testa Kong Gateway
För att testa om Kong Gateway fungerar som förväntat, skicka en förfrågan till den. Kör följande kommando för att skicka en HTTP-förfrågan med `curl`.
``` sh
curl -IL http://localhost:8000
```
Du bör få ett HTTP 404-svar, som indikerar att Kong Gateway tar emot begäran men inga matchande rutter eller tjänster är tillgängliga.
Steg 8:Integration med Kubernetes Services
För att slutföra installationen kan du distribuera en enkel applikation i ditt Kubernetes-kluster och använda Kong Gateway som ingångskontroller för att dirigera förfrågningar till applikationen.
Här är ett exempel på "Deployment"-manifest för en enkel applikation som heter "nginx":
``` jaml
apiVersion:apps/v1
typ:Implementering
metadata:
namn:nginx
etiketter:
app:nginx
spec:
väljare:
matchetiketter:
app:nginx
kopior:1
mall:
metadata:
etiketter:
app:nginx
spec:
behållare:
- namn:nginx
bild:nginx:1.21
hamnar:
- containerPort:80
namn:http
```
Spara den i en fil som heter `nginx.yaml`. Sedan distribuerar du det till ditt Kubernetes-kluster:
``` sh
kubectl tillämpa -f nginx.yaml
```
Detta skapar en distribution för en enkel Nginx-server.
#### Skapa tjänsten
Skapa sedan en Kubernetes-tjänst som exponerar port 80 för alla pods med etiketten `app=nginx`:
``` jaml
apiVersion:v1
slag:Service
metadata:
namn:nginx
etiketter:
app:nginx
spec:
hamnar:
- port:80
namn:http
väljare:
app:nginx
```
Spara den i en fil som heter `nginx-service.yaml`. Sedan distribuerar du det till ditt Kubernetes-kluster:
``` sh
kubectl tillämpa -f nginx-service.yaml
```
#### Skapar KongRoute
Slutligen, konfigurera Kong Gateway för att dirigera trafik till vår `nginx`-tjänst. Nedan är ett exempel på manifest för en KongRoute:
``` jaml
apiVersion:konghq.com/v1
typ:KongRoute
metadata:
namn:exempel
spec:
protokoll:
- https
värd:example.com
vägar:
- /
service:
namn:nginx-kong
port:80
protokoll:http
```
Spara detta manifest i en fil med namnet `example-route.yaml` och tillämpa det på ditt Kubernetes-kluster:
``` sh
kubectl tillämpa -f example-route.yaml
```
Detta skapar en konfiguration som säger åt Kong Gateway att acceptera HTTPS-förfrågningar till domänen `example.com` och dirigera dem till vår `nginx`-tjänst som körs på port 80 med HTTP.
Testa routing
Nu kan du testa Kong Gateway routing. Från vilken dator som helst med åtkomst till Kubernetes-klustret, kör:
``` sh
curl -k https://example.com
```
Om allt är korrekt inställt bör du se standard Nginx välkomstsida.
Grattis! Du har framgångsrikt installerat Kong Gateway på Ubuntu Linux, konfigurerat Ingress Controller, konfigurerat nätverkspolicyer och testat routing till ett program i ditt Kubernetes-kluster.
