Ricerca nel sito web

Che cos'è Ingress Controller e come distribuire Nginx Ingress Controller in Kubernetes Cluster su AWS utilizzando Helm

Su questa pagina

  1. Prerequisiti
  2. Cosa faremo?
  3. Crea un cluster Kubernetes utilizzando Kops
  4. Configura il controller di ingresso Nginx utilizzando Helm
  5. Crea un Recordset in Route53 che punta al LoadBalancer creato dal controller di ingresso Nginx
  6. Crea file di definizione dell'oggetto per un'applicazione di esempio
  7. Distribuisci applicazioni di esempio
  8. Distribuisci un oggetto Ingress
  9. Conclusione

Prima di procedere con l'installazione dell'Nginx Ingress Controller, vediamo in breve cos'è Ingress e Ingress Controller. L'obiettivo di questo articolo è l'installazione, si presuppone che tu abbia familiarità con tutti i prerequisiti per l'impostazione di Nginx Ingress Controller nel cluster Kubernetes.

Kubernetes Ingress

È un oggetto Kubernetes che gestisce l'accesso esterno ai servizi nel cluster Kubernetes. Espone le route HTTP e HTTPS dall'esterno del cluster Kubernetes ai servizi all'interno del cluster Kubernetes.

Controller di ingresso

Per utilizzare Ingress, devi disporre del controller Ingress 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 gli 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

  1. Account AWS (Crea se non ne hai uno).
  2. Kops 1.18.2 installato sulla tua macchina (fai clic qui per imparare a creare un cluster Kubernetes utilizzando Kops e saperne di più.)
  3. Helm v3.5.3  (Fai clic qui per imparare a installare Helm su Ubuntu Server)
  4. Bucket S3 (Fai clic qui per imparare a creare un bucket S3 su AWS).
  5. Nome di dominio (fai clic qui per sapere come registrare un dominio su AWS).
  6. Ruolo IAM con autorizzazioni di amministratore (fai clic qui per imparare a creare un ruolo IAM su AWS).

Che cosa faremo?

  1. Crea un cluster Kubernetes utilizzando Kops
  2. Configura il controller di ingresso Nginx utilizzando Helm
  3. Crea un Recordset in Route53 che punta al LoadBalancer creato dal controller di ingresso Nginx
  4. Crea file di definizione dell'oggetto per un'applicazione di esempio
  5. Distribuisci un'applicazione di esempio
  6. Distribuisci un oggetto Ingress

Crea un cluster Kubernetes utilizzando 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 vedere alcun cluster quando provi a ottenere i cluster utilizzando il seguente comando.

kops get clusters

Visita la documentazione specificata nei prerequisiti per comprendere Kops in dettaglio. Qui, per creare un cluster Kubernetes esegui il seguente comando 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 Zone.

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

Sarà comunque necessario 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

Verifica se il cluster è pronto o meno.

kops validate cluster --wait 10m

È necessario attendere un po' di tempo prima che il cluster diventi 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 seguente comando.

kubectl get pods -A

Configura il controller di ingresso Nginx utilizzando Helm

Una volta che il cluster Kubernetes è pronto e integro, sei pronto per installare Nginx Ingress Controller utilizzando Helm.

Prima di procedere, verifica di disporre di Helm v3.5.3.

Nota: ho utilizzato il file binario di Helm presente 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, fare 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 Helm è stato installato.

Puoi controllare le risorse che sono state create come parte del controller di ingresso.

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 dal controller di ingresso Nginx

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 che abbiamo 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 dell'oggetto per un'applicazione di esempio

Ora, creiamo i file di definizione dell'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 la creazione di regole Ingress 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 sul mio repository Github qui.

Distribuire applicazioni di esempio

Consente di distribuire le applicazioni di esempio una per una e verificarne lo 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 del pod Nginx.

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, ad esempio 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

nginx-deploy-green è accessibile 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 del controller di ingresso Nginx tramite Helm e sulla creazione di un routing basato sul percorso tramite la risorsa Ingress. Abbiamo distribuito 3 diverse applicazioni di esempio e provato ad accedervi utilizzando lo stesso nome host e percorsi diversi.