Prima di procedere con l'installazione di Nginx Ingress Controller, vediamo in breve cos'è Ingress e Ingress Controller. L'obiettivo di questo articolo è la configurazione, si presume che tu abbia familiarità con tutti i prerequisiti per la configurazione di Nginx Ingress Controller nel cluster Kubernetes.
Ingresso Kubernetes
È un oggetto Kubernetes che gestisce l'accesso esterno ai servizi nel cluster Kubernetes. Espone percorsi HTTP e HTTPS dall'esterno del cluster Kubernetes ai servizi all'interno del cluster Kubernetes.
Controllore dell'ingresso
Per utilizzare Ingress, devi avere Ingress Controller nel cluster Kubernetes. Non fa parte del cluster Kubernetes come altri controller nel cluster, non si avvia automaticamente nel cluster. Possiamo distribuire qualsiasi numero di controller di ingresso nel cluster Kubernetes. Per fare ciò, dovremmo annotare ogni ingresso con l'appropriato ingress.class. Sono disponibili molti tipi diversi di controller di ingresso. Ingress Controller è un LoadBalancer per ambienti Kubernetes. Viene utilizzato come soluzione di gestione del traffico per gli ambienti Kubernetes.
In questo articolo, vedremo l'installazione del controller di ingresso Nginx utilizzando Helm sul cluster Kubernetes configurato utilizzando Kops. Per conoscere in dettaglio Nginx Ingress Controller, visita la documentazione ufficiale qui.
Prerequisiti
- Account AWS (crea se non ne hai uno).
- Kops 1.18.2 installato sul tuo computer (fai clic qui per imparare a creare un cluster Kubernetes utilizzando Kops e saperne di più.)
- Helm v3.5.3 (fai clic qui per imparare a installare Helm su Ubuntu Server)
- Bucket S3 (fai clic qui per imparare a creare un bucket S3 su AWS).
- Nome dominio (fai clic qui per imparare a registrare un dominio su AWS).
- Ruolo IAM con autorizzazioni di amministratore (fai clic qui per imparare a creare un ruolo IAM su AWS).
Cosa faremo?
- Crea un cluster Kubernetes utilizzando Kops
- Imposta Nginx Ingress Controller utilizzando Helm
- Crea un recordset in Route53 che punta al LoadBalancer creato dal controller di ingresso Nginx
- Crea file di definizione oggetto per un'applicazione di esempio
- Distribuisci un'applicazione di esempio
- Distribuisci un oggetto Ingress
Crea un cluster Kubernetes usando Kops
Prima di procedere con la creazione del cluster, esporta l'accesso utente AWS IAM e le chiavi segrete utilizzando i seguenti comandi.
export AWS_ACCESS_KEY_ID=<your-aws-access-key-here> #Export AWS Access Key
export AWS_SECRET_ACCESS_KEY=<your-aws-secret-key-here> ##Export AWS Secret Key export
Now, export the KOPS_STATE_STORE variable with value as S3 bucket name on your terminal.
KOPS_STATE_STORE=s3://<s3-bucket-name>
Se stai creando un cluster per la prima volta utilizzando Kops e utilizzando il bucket S3 sopra specificato per l'archiviazione della configurazione del cluster, non dovresti visualizzare alcun cluster quando tenti di ottenere i cluster utilizzando il comando seguente.
kops get clusters
Visita la documentazione specificata nei prerequisiti per comprendere Kops in dettaglio. Qui, per creare un cluster Kubernetes, esegui il comando seguente sostituendo i valori. Non entrerò nei dettagli qui.
kops create cluster --name <subdomain.domain.com> --state s3://<s3-bucket> --cloud aws --master-size t2.small --master-count 1 --master-zones us-east-1a --node-size t2.small --node-count 2 --zones us-east-1a,us-east-1b,us-east-1c
Puoi vedere alcuni comandi nel suggerimento.
Ora, questa volta se provi a ottenere la configurazione del cluster vedrai il nome del cluster nell'output insieme a Cloud e Zones.
Fino a questo punto, il cluster non è stato creato, eseguire il seguente comando per aggiornare la configurazione del cluster.
kops update cluster --name kops.devopslee.com
Dovrai comunque eseguire il comando precedente con --yes come opzione in modo che le risorse del cluster vengano create.
kops update cluster --name kops.devopslee.com --yes
Convalida se il cluster è pronto o meno.
kops validate cluster --wait 10m
È necessario attendere un po' di tempo prima che il cluster sia integro.
kops validate cluster --wait 10m
Una volta che il cluster è integro, puoi controllare i pod predefiniti in tutti gli spazi dei nomi utilizzando il comando seguente.
kubectl get pods -A
Configura il controller di ingresso Nginx utilizzando Helm
Una volta che il cluster Kubernetes è pronto e integro, puoi installare Nginx Ingress Controller utilizzando Helm.
Prima di procedere, verifica di avere Helm v3.5.3.
Nota:ho utilizzato Helm binary present nella mia posizione attuale, quindi puoi vedere ./helm negli screenshot.
helm version
Aggiungi il repository e installa il grafico Helm del controller di ingresso Nginx utilizzando i seguenti comandi. Per comprendere Helm, fai riferimento alla documentazione menzionata nella sezione dei prerequisiti.
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.publishService.enabled=true
Nello screenshot sopra, puoi vedere che il grafico di Helm è stato installato.
Puoi controllare le risorse che sono state create come parte di Ingress Controller.
kubectl get pods
kubectl get deployment
kubectl get service
Nello screenshot sopra, puoi vedere che è stato creato anche il servizio "nginx-ingress-ingress-nginx-controller" di tipo LoadBalancer. Significa che è stato creato un LoadBalancer nell'account AWS.
Crea un recordset in Route53 che punta al LoadBalancer creato da Nginx Ingress Titolare
Vai al tuo account AWS nella regione in cui hai creato il tuo cluster Kubernetes. Controlla il LoadBalancer e copia il suo nome DNS.
Ora vai su Route53 e crea un singolo record A nella HostedZone.
Una volta creato un record valido, il record creato verrà utilizzato per instradare il traffico al cluster Kubernetes tramite il controller di ingresso Nginx che abbiamo creato. In questo caso, kops.devopslee.com indirizzerà il traffico ai servizi nel cluster Kubernetes tramite il controller di ingresso Nginx.
Crea file di definizione oggetto per un'applicazione di esempio
Ora creiamo file di definizione oggetto per distribuire un'applicazione di esempio. Distribuiremo 3 applicazioni utilizzando 3 distribuzioni e 3 rispettivi servizi per le distribuzioni. Creeremo quindi una risorsa Ingress con routing basato sul percorso per instradare il traffico alle nostre applicazioni utilizzando kops.devopslee.com in base al percorso.
Crea 1-nginx-main-app.yaml per l'applicazione 1.
Link Github:fai clic qui per copiare il file dal mio repository Github.
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: nginx
name: nginx-deploy-main
spec:
replicas: 1
selector:
matchLabels:
run: nginx-main
template:
metadata:
labels:
run: nginx-main
spec:
containers:
- image: nginx
name: nginx
---
apiVersion: v1
kind: Service
metadata:
name: nginx-deploy-main
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 80
selector:
run: nginx-main
Crea 2-nginx-green-app.yaml per l'applicazione 2.
Link Github:fai clic qui per copiare il file dal mio repository Github.
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: nginx
name: nginx-deploy-green
spec:
replicas: 1
selector:
matchLabels:
run: nginx-green
template:
metadata:
labels:
run: nginx-green
spec:
volumes:
- name: webdata
emptyDir: {}
initContainers:
- name: web-content
image: busybox
volumeMounts:
- name: webdata
mountPath: "/webdata"
command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=green>GREEN</font></h1>" > /webdata/index.html']
containers:
- image: nginx
name: nginx
volumeMounts:
- name: webdata
mountPath: "/usr/share/nginx/html"
---
---
apiVersion: v1
kind: Service
metadata:
name: nginx-deploy-green
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 80
selector:
run: nginx-green
Crea 3-nginx-blue-app.yaml per l'applicazione 3
Link Github:fai clic qui per copiare il file dal mio repository Github.
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
run: nginx
name: nginx-deploy-blue
spec:
replicas: 1
selector:
matchLabels:
run: nginx-blue
template:
metadata:
labels:
run: nginx-blue
spec:
volumes:
- name: webdata
emptyDir: {}
initContainers:
- name: web-content
image: busybox
volumeMounts:
- name: webdata
mountPath: "/webdata"
command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=blue>BLUE</font></h1>" > /webdata/index.html']
containers:
- image: nginx
name: nginx
volumeMounts:
- name: webdata
mountPath: "/usr/share/nginx/html"
---
apiVersion: v1
kind: Service
metadata:
name: nginx-deploy-blue
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 80
selector:
run: nginx-blue
Crea 4-ingress.yaml per creare regole di ingresso basate sul percorso.
Link Github:fai clic qui per copiare il file dal mio repository Github.
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
name: ingress-resource
spec:
rules:
- host: kops.devopslee.com
http:
paths:
- path: /
backend:
serviceName: nginx-deploy-main
servicePort: 80
- path: /blue
backend:
serviceName: nginx-deploy-blue
servicePort: 80
- path: /green
backend:
serviceName: nginx-deploy-green
servicePort: 80 Puoi trovare tutti questi file nel mio repository Github qui.
Distribuisci applicazioni di esempio
Distribuiamo le applicazioni di esempio una per una e controlliamo il loro stato.
kubectl apply -f 1-nginx-main-app.yaml
kubectl apply -f 2-nginx-green-app.yaml
kubectl apply -f 3-nginx-blue-app.yaml
kubectl get deployments
kubectl get pods
kubectl get service
Distribuisci un oggetto Ingress
Ora è il momento di creare una risorsa Ingress di routing basata sul percorso. Allo stesso tempo, controlla i log di Nginx Pod.
kubectl logs nginx-ingress-ingress-nginx-controller-5c97c6b4d5-btvpl -f
kubectl apply -f 4-ingress.yaml
Non appena viene creata la risorsa Ingress, puoi vedere che Nginx ha caricato la sua configurazione.
E ora, 3 diverse applicazioni sono pronte per l'accesso utilizzando lo stesso nome host, ovvero kops.devopslee.com, su percorsi diversi.
URL per le applicazioni, il nome host qui sarà diverso per te.
È possibile accedere a nginx-deploy-main su kops.devopslee.com
È possibile accedere a nginx-deploy-green su kops.devopslee.com/green e
È possibile accedere a nginx-deploy-blue su kops.devopslee.com/blue
Puoi vedere che è possibile accedere a 3 diverse applicazioni utilizzando lo stesso nome host in base al percorso.
Conclusione
In questo articolo, abbiamo visto i passaggi per creare un cluster Kubernetes utilizzando Kops. Questo articolo si è concentrato principalmente sulla configurazione di Nginx Ingress Controller utilizzando Helm e sulla creazione di un routing basato sul percorso utilizzando la risorsa Ingress. Abbiamo distribuito 3 diverse applicazioni di esempio e abbiamo provato ad accedervi utilizzando lo stesso nome host e percorsi diversi.