Como ingeniero de software, llevo más de 15 años utilizando metodologías de Entrega Continua (CD) e Integración Continua (CI).

La idea detrás de CI/CD es muy simple: permitir a los equipos que desplieguen de manera automática las aplicaciones cuando hay cambios en el código fuente en entornos de pruebas o de producción fácilmente.

Además, automatizar el proceso de CI/CD nos ahorra tiempo y elimina los errores humanos. Sin embargo, la creación de flujos de trabajo CI/CD con herramientas como Jenkins o Gitlab no es tan fácil y rápida como se piensa.

Hoy en día, la situación es aún peor en la era de los microservicios cuando se necesita orquestar el despliegue de decenas o cientos de servicios al mismo tiempo. ¡Qué pesadilla!

Sin embargo, ¿qué dirías si puedo desplegar un montón de servicios en Kubernetes directamente desde GIT en menos de 10 minutos? No te preocupes y veámoslo por nosotros mismos ?

ArgoCD

Para este reto, vamos a utilizar ArgoCD, una herramienta declarativa de entrega continua GitOps creada para Kubernetes y un proyecto de la incubadora de la Cloud Native Computing Foundation.

ArgoCD utiliza repositorios Git como fuente de la verdad definiendo el estado deseado de cada aplicación.

Sus principales características son:

• Despliegue automatizado de aplicaciones en entornos concretos.
• Compatible con Kustomize, Helm, plain-YAML, etc.
• Capaz de hacer Rollback a cualquier configuración anterior guardada en el repositorio Git.

ArgoCD se ejecuta como un controlador en kubernetes que supervisa continuamente las aplicaciones en ejecución y compara su estado actual, con el estado deseado, tal y como se especifica en el repositorio de Git.

Requisitos Prévios

Antes de comenzar, necesitarás:

• Un clúster de Kubernetes en tu PC. Ver Docker Desktop o Minkube
• Una cuenta de Github y GitHub CLI instalado.

1. Instalar ArgoCD – 1 min

Como hemos visto antes, ArgoCD se ejecuta como un operador en Kubernetes y tenemos que desplegarlo dentro del cluster.

Además, necesitamos crear un nuevo namespace llamado “argocd” donde se ejecutarán todos los servicios de ArgoCD.

• Crea un namespace para ArgoCD:

kubectl create namespace argocd

• Instala ArgoCD en Kubernetes:

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

• Finalmente, instala el cliente de ArgoCD en tu ordenador: utiliza su manual oficial

2. Configurar ArgoCD – 2 min

Aunque ya tenemos ArgoCD instalado en nuestro clúster Kubernetes, no vamos a poder acceder a él.

Para solucionarlo, expondremos su servidor API / UI al exterior y configuraremos el cliente para utilizarlo.

• Expón el servidor API de ArgoCD de manera interna:

kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

• Configura ArgoCD CLI con nombre de usuario “admin” y contraseña  “admin”:

kubectl -n argocd patch secret argocd-secret \
    -p '{"stringData": {"admin.password": "$2a$10$mivhwttXM0U5eBrZGtAG8.VSRL1l9cZNAmaSaqotIzXRBRwID1NT.",
        "admin.passwordMtime": "'$(date +%FT%T)'"
    }}'
argocd login localhost:10443 --username admin --password admin --insecure

• Expón la interfaz de usuario de ArgoCD de manera externa:

kubectl port-forward svc/argocd-server -n argocd 10443:443 2>&1 > /dev/null &

• Por último, abre la interfaz de usuario de ArgoCD en su navegador: https://localhost:10443.

3. Crear un repositorio GIT de despliegue – 2 min

Como hemos visto antes, ArgoCD utiliza un repositorio GIT como fuente de la verdad. Por lo tanto, debemos crear un repositorio con la configuración de nuestra aplicación de Kubernetes en una de sus formas compatibles. En nuestro caso, vamos a utilizar un simple archivo yaml de K8s.

• Crea un nuevo repositorio en tu cuenta de Github

gh repo create --public git2k8s10min -y && cd git2k8s10min

• Crea un fichero readme.md y súbelo a Github

echo "From GIT to Kubernetes in 10 minutes with ArgoCD." > Readme.md
git add Readme.md
git commit -m "Added Readme.md" && git push --set-upstream origin master

• Crea una nueva rama de producción y súbela sin nuevos cambios a Github

git branch live
git push --set-upstream origin live

• Sube el archivo de despliegue «Libro de visitas» y confirma los cambios en Github

git checkout master
curl -kSs https://raw.githubusercontent.com/kubernetes/examples/master/guestbook/all-in-one/guestbook-all-in-one.yaml -o guestbook_app.yaml
git add guestbook_app.yaml
git commit -m "Added guestbook_app.yaml"
git push --set-upstream origin master

4. Desplegar con ArgoCD – 3 min

Después de que el repositorio esté listo, debemos crear una aplicación ArgoCD utilizando su propio recurso de kubernetes. Además, vamos a crear un nuevo namespace para desplegar en él.

• Obtén la url del repositorio GIT:

HTTPS_REPO_URL=$(git remote show origin |  sed -nr 's/.+Fetch URL: git@(.+):(.+).git/https:\/\/\1\/\2.git/p')

• Crea el namespace en k8s:

kubectl create namespace git2k8s10min

• Despliega la aplicación:

cat <<EOF | kubectl apply -f -
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: git2k8s10min
  namespace: argocd
spec:
  destination:
    namespace: git2k8s10min
    server: https://kubernetes.default.svc
  project: default
  source:
    repoURL: $HTTPS_REPO_URL
    path: .
    targetRevision: master
EOF

• Aunque la aplicación está creada, no ha sido «desplegada». Así que tienes que sincronizar la aplicación manualmente

argocd app sync git2k8s10min

• Comprueba el estado de la aplicación utilizando Arcgocd CLI

argocd app get git2k8s10min

• Comprueba los recursos de Kubernetes utilizando kubectl

kubectl get -n git2k8s10min svc/frontend pods

• Ejecuta el siguiente comando para reenviar el tráfico desde el puerto 18080 de tu máquina al puerto 80 del servicio

kubectl port-forward -n git2k8s10min svc/frontend 18080:80

Por último, probar de nuevo acceder a http://localhost:18080/ desde tu navegador para ver la aplicación del Libro de Visitas.

5. Nuevo despliegue en modo automático – 2 min

En los últimos 2 minutos, vamos a ver cómo ArgosCD sincroniza automáticamente las aplicaciones basadas en los commits de GIT como si estuviéramos trabajando en múltiples entornos. La idea es:

• Simular un entorno de producción.
• Desplegar la aplicación con la rama viva creada utilizando una rama sin recursos.
• Actualizar la rama con el último commit que añada el archivo yaml.
• Esperar a que ArgoCD actualice la app automáticamente.

Vamos al turrón:

• Crea un nuevo namespace para el entorno de producción:

kubectl create namespace git2k8s10min-live

• Despliegua una nueva aplicación en modo automático y escuchando la rama de producción:

cat <<EOF | kubectl apply -f -
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: git2k8s10min-live
  namespace: argocd
spec:
  destination:
namespace: git2k8s10min-live
server: https://kubernetes.default.svc
project: default
source:
repoURL: $HTTPS_REPO_URL
path: .
targetRevision: live
syncPolicy:
automated: {}
EOF

• Ahora, ya deberemos de poder ver la aplicación, pero sin recursos.
• Sincroniza la rama de producción:

git checkout live

git merge master

git push –set-upstream origin live

• Vuelve a la interfaz de ArgoCD y esperar a que se apliquen los cambios

¡Lo conseguimos!

Tras unos pasos sencillos, hemos sido capaces de desplegar una aplicación en 2 entornos en 10 minutos. ¡Ha sido pan comido!

Además, hemos aprendido un montón de cosas:

• Cómo usar GIT como fuente de verdad de tus despliegues.
• Cómo hacer GitOps de manera sencilla con ArgoCD.
• Cómo desplegar automáticamente en múltiples entornos utilizando diferentes ramas de GIT.

¡Gracias y nos vemos en el próximo reto!

Santander Global Tech es la empresa de tecnología global, parte de la división de Technology and Operations (T&O) de Santander. Con más de 2.000 empleados y basada en Madrid, trabajamos para convertir al Santander en una plataforma abierta de servicios financieros.

¿Quieres unirte a este equipazo? Mira las posiciones que tenemos abiertas aquí y Be Tech! with Santander ?

Síguenos en LinkedIn y en Instagram.

Álvaro Santos Andrés

Santander

Arquitecto de Cloud Solution con más de 15 años de experiencia. En los últimos años he liderado múltiples proyectos en la public cloud y he diseñado estrategias de migración a la nube para varias empresas. También soy arquitecto profesional de AWS y GCP.

• Programación