- Un server Ubuntu 20.04 con un utente non root con privilegi "sudo".
- Un cluster Kubernetes installato sul server, come `kubeadm`, `k3s`, `minikube`, `Rancher`, ecc.
- Accesso alla finestra della riga di comando/terminale.
Aggiorna gli elenchi dei pacchetti prima di procedere con qualsiasi installazione:
```sh
sudo apt update &&sudo apt upgrade -y
```
Importa la chiave GPG per il repository Kubernetes, che aiuta a identificare l'editore del pacchetto.
```sh
ricciolo https://download.konghq.com/keyring/kong.gpg | sudo apt-key add -
```
Crea l'elenco dei repository di Kong in modo che apt possa ottenere Kong dalla fonte ufficiale.
```sh
echo "deb [arch=amd64] https://download.konghq.com/deb stable main" | sudo tee /etc/apt/sources.list.d/kong.list
```
Ora installa Kong Gateway utilizzando il gestore pacchetti standard, apt.
```sh
sudo apt installa kong
```
Questo comando dovrebbe installare Kong Gateway e tutte le sue dipendenze.
Una volta completata l'installazione, esegui il comando seguente per abilitare il servizio Kong:
```sh
sudo systemctl abilita kong
```
E poi, avvia il servizio Kong:
```sh
sudo systemctl avvia kong
```
Per verificare se il servizio Kong è in esecuzione, utilizzare il seguente comando:
```sh
sudo systemctl stato kong
```
Successivamente installeremo Kong Ingress Controller, che funge da ponte tra Kong Gateway e Kubernetes.
Esegui il comando seguente per installare Kong Ingress Controller utilizzando Helm, il gestore pacchetti Kubernetes:
```sh
helm repo aggiungi kong https://charts.konghq.com
Aggiornamento del repository del timone
helm install kong/kong-ingress-controller --namespace=kong --create-namespace
```
Questo installa Kong Ingress Controller in uno spazio dei nomi `kong` appena creato.
Per impostazione predefinita, Kong Gateway ascolta le richieste sull'interfaccia locale e sulla porta 8000. Per consentire l'accesso remoto dall'esterno del tuo server, ad esempio dai client nel tuo cluster, dobbiamo configurare le policy di rete di Kubernetes.
Crea la policy di rete necessaria utilizzando `kubectl`:
```sh
kubectl create -f - <
tipo:NetworkPolicy
metadati:
nome:consenti-traffico
specifica:
podSelettore:{}
ingresso:
- da:
- namespaceSelector:
matchEtichette:
nome:kong
porti:
- porto:8000
protocollo:TCP
EOF
```
Questa politica di rete consente a tutti i pod nello spazio dei nomi "kong" di inviare traffico a Kong Gateway.
Per verificare se Kong Gateway funziona come previsto, inviagli una richiesta. Esegui il comando seguente per inviare una richiesta HTTP utilizzando "curl".
```sh
curl -IL http://localhost:8000
```
Dovresti ricevere una risposta HTTP 404, che indica che Kong Gateway sta ricevendo la richiesta ma non sono disponibili percorsi o servizi corrispondenti.
Per completare la configurazione, puoi distribuire una semplice applicazione nel tuo cluster Kubernetes e utilizzare Kong Gateway come controller di ingresso per instradare le richieste all'applicazione.
Ecco un esempio di manifest "Deployment" per una semplice applicazione denominata "nginx":
```yaml
apiVersion:app/v1
tipo:distribuzione
metadati:
nome:nginx
etichette:
applicazione:nginx
specifica:
selettore:
matchEtichette:
applicazione:nginx
repliche:1
modello:
metadati:
etichette:
applicazione:nginx
specifica:
contenitori:
- nome:nginx
immagine:nginx:1.21
porti:
- porto container:80
nome:http
```
Salvalo in un file denominato "nginx.yaml". Quindi, distribuiscilo sul tuo cluster Kubernetes:
```sh
kubectl apply -f nginx.yaml
```
Questo crea una distribuzione per un semplice server Nginx.
#### Creazione del servizio
Successivamente, crea un servizio Kubernetes che esponga la porta 80 di tutti i pod con l'etichetta "app=nginx":
```yaml
APIVersione:v1
gentile:servizio
metadati:
nome:nginx
etichette:
applicazione:nginx
specifica:
porti:
- porto:80
nome:http
selettore:
applicazione:nginx
```
Salvalo in un file denominato "nginx-service.yaml". Quindi, distribuiscilo sul tuo cluster Kubernetes:
```sh
kubectl apply -f nginx-service.yaml
```
#### Creazione di KongRoute
Infine, configura Kong Gateway per instradare il traffico al nostro servizio "nginx". Di seguito è riportato un esempio di manifest per un KongRoute:
```yaml
APIVersione:konghq.com/v1
tipo:KongRoute
metadati:
nome:esempio
specifica:
protocolli:
- https
host:esempio.com
percorsi:
-/
servizio:
nome:nginx-kong
porto:80
protocollo:http
```
Salva questo manifest in un file denominato "example-route.yaml" e applicalo al tuo cluster Kubernetes:
```sh
kubectl apply -f esempio-route.yaml
```
Questo crea una configurazione che dice a Kong Gateway di accettare le richieste HTTPS al dominio "example.com" e di instradarle al nostro servizio "nginx" in esecuzione sulla porta 80 utilizzando HTTP.
Ora puoi testare il routing di Kong Gateway. Da qualsiasi macchina con accesso al cluster Kubernetes, esegui:
```sh
curl -k https://esempio.com
```
Se tutto è impostato correttamente, dovresti vedere la pagina di benvenuto di Nginx predefinita.
Congratulazioni! Hai installato correttamente Kong Gateway su Ubuntu Linux, impostato il controller di ingresso, configurato i criteri di rete e testato il routing a un'applicazione nel tuo cluster Kubernetes.
Passaggio 7:testare il Kong Gateway
Passaggio 8:integrazione con i servizi Kubernetes
Test del percorso
Informazioni correlate
sistemi © www.354353.com