Introducción
Probar una nueva función o actualización en producción es un proceso estresante. Desea implementar cambios con frecuencia pero sin afectar la experiencia del usuario. Para minimizar el tiempo de inactividad durante esta fase, configure implementaciones canary para agilizar la transición.
Puede usar implementaciones canary en cualquier infraestructura. En consecuencia, es una de las estrategias de implementación en Kubernetes.
Aprenda qué son las implementaciones canary, cómo funcionan y cómo realizar una implementación canary en Kubernetes.
Requisitos previos
- Acceso a una línea de comando/terminal
- Docker instalado en el sistema
- Kubernetes o Minikube
- Una herramienta de línea de comandos de kubectl completamente configurada en su máquina local
¿Qué es una implementación canaria?
Una implementación canary es una versión mejorada de una implementación existente, con todo el código de aplicación y las dependencias necesarias. Se utiliza para probar nuevas funciones y actualizaciones para ver cómo manejan el entorno de producción.
Cuando agrega la implementación canary a un clúster de Kubernetes, un servicio lo administra a través de selectores y etiquetas . El servicio enruta el tráfico a los pods que tienen la etiqueta especificada. Esto le permite agregar o eliminar implementaciones fácilmente.
La cantidad de tráfico que obtiene el canary corresponde a la cantidad de pods que genera. En la mayoría de los casos, comienza enrutando un porcentaje menor de tráfico al canary y aumenta el número con el tiempo.
Con ambas implementaciones configuradas, supervisa el comportamiento del control controlado para ver si surge algún problema. Una vez que esté satisfecho con la forma en que maneja las solicitudes, puede actualizar todas las implementaciones a la última versión.
Configuración de Canary Deployment en Kubernetes
Los pasos a continuación le muestran cómo configurar una implementación canary. Para este artículo, creamos un clúster de Kubernetes simple de pods de Nginx con una página HTML estática básica de dos oraciones. Las versiones de la implementación varían según el contenido que muestran en la página web.
El proceso de configuración de su implementación Canary diferirá según la aplicación que esté ejecutando.
Paso 1:extraer la imagen de Docker
El primer paso es extraer o crear la imagen para los contenedores en su clúster de Kubernetes. Dado que estamos construyendo contenedores Nginx en este ejemplo, usamos la imagen Nginx disponible en Docker Hub.
1. Descarga la imagen con:
docker pull nginx2. Verifique que lo tenga enumerando todas las imágenes locales:
docker image ls
Paso 2:Cree la implementación de Kubernetes
1. Cree la definición de implementación mediante un archivo yaml. Utilice un editor de texto de su elección y proporcione un nombre para el archivo. Vamos a nombrar el archivo nginx-deployment.yaml y créalo con Nano :
nano nginx-deployment.yaml2. Agregue el siguiente contenido al archivo:
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
Creamos 3 réplicas de pods de Nginx para el clúster de Kubernetes. Todos los pods tienen la etiqueta version: "1.0 ". Además, tienen un volumen de host que contiene el index.html montado en el contenedor. El archivo HTML de muestra que consta de:
<html>
<h1>Hello World!</h1>
<p>This is version 1</p>
</html>3. Guarde y salga del archivo.
4. Cree la implementación ejecutando:
k apply -f nginx-deployment.yaml5. Compruebe si ha implementado correctamente los pods con:
k get pods -o wideEl resultado debe mostrar tres pods de Nginx en ejecución .
Paso 3:Crear el Servicio
El siguiente paso es crear una definición de servicio para el clúster de Kubernetes. El servicio enrutará las solicitudes a los pods especificados.
1. Crea un nuevo yaml archivo con:
nano nginx-deployment.service.yaml2. Luego, agregue el siguiente contenido:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
version: "1.0"
ports:
- port: 8888
targetPort: 80
El archivo yaml especifica el tipo de servicio:LoadBalancer . Le indica al servicio que equilibre las cargas de trabajo entre los pods con las etiquetas app: nginx y version: "1.0" . El pod debe tener ambas etiquetas para ser parte del servicio.
3. Guarde y salga del archivo de servicio.
4. Ahora, crea el servicio:
kubectl apply -f nginx-deployment.service.yamlPaso 4:comprobar la primera versión del clúster
Para verificar que el servicio se está ejecutando, abra un navegador web y navegue hasta la IP y el número de puerto definidos en el archivo del servicio.
Para ver la dirección IP externa del servicio, utilice el comando:
kubectl get serviceSi está ejecutando Kubernetes localmente , use localhost como IP.
Dado que el clúster de muestra que creamos se ejecuta localmente en el puerto 8888, la URL es:
http://localhost:8888
El navegador debe mostrar un Hello World mensaje de versión 1 .
Paso 5:Cree una implementación canaria
Con versión 1 de la aplicación en su lugar, implementa la versión 2 , el despliegue canario.
1. Comienza creando el yaml archivo para la implementación de Canary. Ejecute el comando:
nano nginx-canary-deployment.yaml2. Agregue el siguiente contenido al archivo:
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/v2El contenido del archivo de implementación Canary difiere en tres parámetros importantes:
- El nombre en los metadatos es
nginx-canary-deployment. - Tiene la etiqueta
version: “2.0”. - Está vinculado a un archivo html index.html que consta de:
<html>
<h1>Hello World!</h1>
<p>This is version 2</p>
</html>3. Guarde y salga del archivo.
4. Cree la implementación canary con el comando:
k apply -f nginx-canary-deployment.yaml5. Verifique que haya implementado correctamente los tres pods adicionales:
k get pods -o wideEl resultado debe mostrar los vainas de implementación canary de Nginx , junto con los pods Nginx originales .
Paso 6:ejecutar la implementación de Canary
Abra un navegador web y navegue a la misma dirección IP que en el Paso 4. Notará que no hay cambios en la página web. Esto se debe a que el archivo de servicio está configurado para equilibrar la carga solo de pods con la etiqueta version: "1.0" .
Para probar los pods actualizados, debe modificar el archivo de servicio y dirigir parte del tráfico a version: "2.0" .
1. Para hacerlo, abre yaml archivo con:
nano nginx-deployment.service.yaml
2. Busque y elimine la línea version: “1.0” . El archivo debe incluir lo siguiente:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
ports:
- port: 8888
targetPort: 803. Guarde los cambios y salga del archivo.
4. Cree el servicio actualizado con el comando:
k apply -f nginx-deployment.service.yml5. El tráfico ahora se divide entre los pods de la versión 1 y la versión 2. Si actualiza la página web varias veces, verá diferentes resultados según el lugar al que el servicio redirige su solicitud.
Paso 7:Supervise el comportamiento de Canary
Con ambas implementaciones en funcionamiento, supervise el comportamiento de la nueva implementación. Según los resultados, puede revertir la implementación o actualizar a la versión más nueva.
Revertir la implementación de Canary
Si observa que el control controlado no funciona como se esperaba, puede revertir la implementación y eliminar los pods actualizados con:
kubectl delete deployment.apps/nginx-canary-deploymentEl servicio continúa equilibrando la carga del tráfico a los pods iniciales (versión 1).
Lanzamiento de implementación mejorada
Si concluye que la implementación de Canary está funcionando como se esperaba, puede enrutar todo el tráfico entrante a la versión actualizada. Hay tres formas de hacerlo:
1. Actualice la primera versión modificando la imagen de Docker y creando una nueva implementación. Luego, quita los canarios con:
kubectl delete deployment.apps/nginx-canary-deployment2. Puede conservar los pods actualizados y eliminar los que tienen la versión 1 etiqueta:
kubectl delete deployment.apps/nginx
3. Alternativamente, incluso puede modificar el service.yaml archivo y agregue la versión especificador al selector etiqueta. Esto indica al equilibrador de carga que solo dirija el tráfico a la versión 2. vainas.