Introduzione
Testare una nuova funzionalità o un aggiornamento in produzione è un processo stressante. Vuoi implementare le modifiche frequentemente ma senza influire sull'esperienza dell'utente. Per ridurre al minimo i tempi di inattività durante questa fase, configura le implementazioni Canary per semplificare la transizione.
Puoi utilizzare le distribuzioni Canary su qualsiasi infrastruttura. Di conseguenza, è una delle strategie di distribuzione in Kubernetes.
Scopri cosa sono le implementazioni canary, come funzionano e come eseguire un deployment canary su Kubernetes.
Prerequisiti
- Accesso a una riga di comando/terminale
- Docker installato sul sistema
- Kubernetes o Minikube
- Uno strumento da riga di comando kubectl completamente configurato sul tuo computer locale
Cos'è una distribuzione Canary?
Un dispiegamento delle Canarie è una versione aggiornata di una distribuzione esistente, con tutto il codice dell'applicazione e le dipendenze richieste. Viene utilizzato per testare nuove funzionalità e aggiornamenti per vedere come gestiscono l'ambiente di produzione.
Quando aggiungi la distribuzione Canary a un cluster Kubernetes, viene gestita da un servizio tramite selettori e etichette . Il servizio instrada il traffico ai pod che hanno l'etichetta specificata. Ciò ti consente di aggiungere o rimuovere facilmente le distribuzioni.
La quantità di traffico che riceve il canary corrisponde al numero di pod che fa girare. Nella maggior parte dei casi, inizi indirizzando una percentuale minore di traffico alle Canarie e aumenti il numero nel tempo.
Con entrambe le distribuzioni impostate, monitori il comportamento di Canary per vedere se si verificano problemi. Una volta che sei soddisfatto del modo in cui gestisce le richieste, puoi aggiornare tutte le distribuzioni all'ultima versione.
Configurazione di Canary Deployment su Kubernetes
I passaggi seguenti mostrano come impostare una distribuzione Canary. Per questo articolo, abbiamo creato un semplice cluster Kubernetes di pod Nginx con una pagina HTML statica di base di due frasi. Le versioni della distribuzione variano in base al contenuto visualizzato nella pagina Web.
Il processo di configurazione della distribuzione di Canary varia a seconda dell'applicazione in esecuzione.
Passaggio 1:estrai l'immagine Docker
Il primo passaggio consiste nel tirare o creare l'immagine per i contenitori nel tuo cluster Kubernetes. Poiché in questo esempio stiamo creando contenitori Nginx, utilizziamo l'immagine Nginx disponibile su Docker Hub.
1. Scarica l'immagine con:
docker pull nginx2. Verifica di averlo elencando tutte le immagini locali:
docker image ls
Passaggio 2:crea la distribuzione Kubernetes
1. Creare la definizione di distribuzione utilizzando un file yaml. Usa un editor di testo a tua scelta e fornisci un nome per il file. Chiameremo il file nginx-deployment.yaml e crealo con Nano :
nano nginx-deployment.yaml2. Aggiungi il seguente contenuto al file:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx
spec:
selector:
matchLabels:
app: nginx
replicas: 3
template:
metadata:
labels:
app: nginx
version: "1.0"
spec:
containers:
- name: nginx
image: nginx:alpine
resources:
limits:
memory: "128Mi"
cpu: "50m"
ports:
- containerPort: 80
volumeMounts:
- mountPath: /usr/share/nginx/html
name: index.html
volumes:
- name: index.html
hostPath:
path: /Users/sofija/Documents/nginx/v1
Abbiamo creato 3 repliche di pod Nginx per il cluster Kubernetes. Tutti i pod hanno l'etichetta version: "1.0 ". Inoltre, hanno un volume host contenente index.html montato sul contenitore. Il file HTML di esempio composto da:
<html>
<h1>Hello World!</h1>
<p>This is version 1</p>
</html>3. Salva ed esci dal file.
4. Crea la distribuzione eseguendo:
k apply -f nginx-deployment.yaml5. Verifica di aver distribuito correttamente i pod con:
k get pods -o wideL'output dovrebbe visualizzare tre pod Nginx in esecuzione .
Fase 3:crea il servizio
Il passaggio successivo consiste nel creare una definizione di servizio per il cluster Kubernetes. Il servizio indirizzerà le richieste ai pod specificati.
1. Crea un nuovo yaml file con:
nano nginx-deployment.service.yaml2. Quindi, aggiungi il seguente contenuto:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
version: "1.0"
ports:
- port: 8888
targetPort: 80
Il file yaml specifica il tipo di servizio:LoadBalancer . Indica al servizio di bilanciare i carichi di lavoro tra i pod con le etichette app: nginx e version: "1.0" . Il pod deve avere entrambe le etichette per far parte del servizio.
3. Salva ed esci dal file di servizio.
4. Ora crea il servizio:
kubectl apply -f nginx-deployment.service.yamlFase 4:verifica la prima versione del cluster
Per verificare che il servizio sia in esecuzione, apri un browser Web e vai all'IP e al numero di porta definiti nel file del servizio.
Per vedere l'indirizzo IP esterno del servizio, utilizzare il comando:
kubectl get serviceSe esegui Kubernetes localmente , usa localhost come IP.
Poiché il cluster di esempio che abbiamo creato è in esecuzione localmente sulla porta 8888, l'URL è:
http://localhost:8888
Il browser dovrebbe visualizzare un Hello World messaggio dalla versione 1 .
Passaggio 5:crea una distribuzione Canary
Con versione 1 dell'applicazione in atto, distribuisci la versione 2 , il dispiegamento delle Canarie.
1. Inizia creando il yaml file per la distribuzione di Canary. Esegui il comando:
nano nginx-canary-deployment.yaml2. Aggiungi il seguente contenuto al file:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-canary-deployment
spec:
selector:
matchLabels:
app: nginx
replicas: 3
template:
metadata:
labels:
app: nginx
version: "2.0"
spec:
containers:
- name: nginx
image: nginx:alpine
resources:
limits:
memory: "128Mi"
cpu: "50m"
ports:
- containerPort: 80
volumeMounts:
- mountPath: /usr/share/nginx/html
name: index.html
volumes:
- name: index.html
hostPath:
path: /Users/sofija/Documents/nginx/v2Il contenuto del file di distribuzione di Canary differisce per tre parametri importanti:
- Il nome nei metadati è
nginx-canary-deployment. - Ha l'etichetta
version: “2.0”. - È collegato a un file html index.html che consiste in:
<html>
<h1>Hello World!</h1>
<p>This is version 2</p>
</html>3. Salva ed esci dal file.
4. Crea la distribuzione Canary con il comando:
k apply -f nginx-canary-deployment.yaml5. Verifica di aver distribuito correttamente i tre pod aggiuntivi:
k get pods -o wideL'output dovrebbe visualizzare i pod di distribuzione di Nginx Canary , insieme ai pod Nginx originali .
Fase 6:esegui la distribuzione Canary
Apri un browser web e vai allo stesso indirizzo IP del passaggio 4. Noterai che non ci sono modifiche alla pagina web. Questo perché il file di servizio è configurato per bilanciare il carico solo dei pod con l'etichetta version: "1.0" .
Per testare i pod aggiornati, devi modificare il file di servizio e indirizzare parte del traffico alla version: “2.0” .
1. A tale scopo, apri yaml file con:
nano nginx-deployment.service.yaml
2. Trova e rimuovi la riga version: “1.0” . Il file dovrebbe includere quanto segue:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
ports:
- port: 8888
targetPort: 803. Salva le modifiche ed esci dal file.
4. Crea il servizio aggiornato con il comando:
k apply -f nginx-deployment.service.yml5. Il traffico è ora suddiviso tra i pod della versione 1 e della versione 2. Se aggiorni la pagina web alcune volte, vedrai risultati diversi a seconda di dove il servizio reindirizza la tua richiesta.
Fase 7:monitora il comportamento di Canary
Con entrambe le distribuzioni attive e in esecuzione, monitorare il comportamento della nuova distribuzione. A seconda dei risultati, puoi ripristinare la distribuzione o eseguire l'aggiornamento alla versione più recente.
Ripristina la distribuzione Canary
Se noti che il Canary non funziona come previsto, puoi ripristinare la distribuzione ed eliminare i pod aggiornati con:
kubectl delete deployment.apps/nginx-canary-deploymentIl servizio continua a bilanciare il carico del traffico verso i pod iniziali (versione 1).
Distribuzione potenziata
Se concludi che la distribuzione di Canary sta funzionando come previsto, puoi instradare tutto il traffico in entrata alla versione aggiornata. Ci sono tre modi per farlo:
1. Aggiorna la prima versione modificando l'immagine Docker e creando una nuova distribuzione. Quindi, rimuovi i canarini con:
kubectl delete deployment.apps/nginx-canary-deployment2. Puoi conservare i pod aggiornati e rimuovere quelli con la versione 1 etichetta:
kubectl delete deployment.apps/nginx
3. In alternativa, puoi persino modificare service.yaml file e aggiungi la versione specificatore nel selector etichetta. Questo indica al sistema di bilanciamento del carico di indirizzare il traffico solo alla versione 2 baccelli.