Integración de Drone Autoscaler para un ahorro de costos y mejorar la experiencia de los devs

La principal motivo para integrar el escalador automatico de drone es evitar la saturación de trabajos en la cola del drone y un ahorro de costos si decidimos trabajar con instancias Spot, pero antes de empezar
¿Que es Drone?
Drone es una plataforma de entrega continua, simple y de código abierto que automatiza los flujos de trabajo de pruebas y lanzamiento. Está construido en Docker y escrito en Go.
Lo mejor de drone es que se puede usar para multiples propositos como correr test, crear y subir containers a ECR, GCR, podemos correr migraciones, el cielo es el limite.

¿Que necesitamos para usar Drone?
Principalmente una cuenta de Github, tambien podemos usar GitLab, Bitbucket, Gitea y algunos otros pero para este caso vamos a usar Github, el segundo requerimiento seria tener acceso a una cuenta de AWS con permisos para crear instancias EC2 y tener el docker instalado en nuestra maquina inicial.

Instalación del Drone

Primero vamos a necesitar crear un OAuth Apps en Github

Vamos a necesitar el Client ID, Client secret y que el Homepage URL , Authorization callback URL apunten a la URL donde va a estar el drone.

Luego vamos a AWS y levantamos una máquina Ec2, con una t3.small es suficiente, es este vamos a instalar docker, después de esto vamos a necesitar ejecutar este comando en nuestra instancia y debemos guardar la respuesta del comando

openssl rand -hex 16

Ahora si estamos listos para enviar nuestro comando para correr el drone-server, recuerda añadir un admin, el autoscaler requiere un token de usuario admin para poder conectarse al drone server, puede ser tu usuario de admin o también podemos crear un nuevo usuario que tenga los mismos permisos.

sudo docker run \ 
  --volume=/var/lib/drone:/data \
  --env=DRONE_GITHUB_CLIENT_ID=******************** \
  --env=DRONE_GITHUB_CLIENT_SECRET=**************************************** \
  --env=DRONE_RPC_SECRET=******************************** \
  --env=DRONE_SERVER_HOST=drone.organization.com \
  --env=DRONE_SERVER_PROTO=https \
  --env=DRONE_LOGS_DEBUG=true \
  --env=DRONE_TLS_AUTOCERT=true \
  --env=DRONE_USER_CREATE=username:yourgithubuser,admin:true \
  --publish=80:80 \
  --publish=443:443 \
  --restart=always \
  --detach=true \
  --name=drone \
  drone/drone:1


DRONE_GITHUB_CLIENT_ID: Id del OAuth Apps
DRONE_GITHUB_CLIENT_SECRET: Secreto del OAuth Apps
DRONE_RPC_SECRET: La respuesta del comando "openssl rand -hex 16"
DRONE_USER_CREATE: Nuestro usuario de github


Si todo salió bien, al entrar al drone.organization.com debería retornarnos algo similar a esta vista.
Podemos ir a la parte de user settings y usar nuestro token para el siguiente paso, pero también podemos crear nuevo usuario con privilegios de admin y usar su token

Y ahora estamos listos para integrar el drone autoscaler, en la misma instancia que está corriendo el drone server vamos a correr el drone autoscaler

sudo docker run -d -v /var/lib/autoscaler:/data \
  -e DRONE_LOGS_DEBUG=true \
  -e DRONE_POOL_MIN=0 \
  -e DRONE_POOL_MAX=15 \
  -e DRONE_AMAZON_IAM_PROFILE_ARN=arn:aws:iam::************:instance-profile/drone-worker-role \
  -e DRONE_POOL_MIN_AGE=3m \
  -e DRONE_INTERVAL=30s \
  -e DRONE_SERVER_PROTO=https \
  -e DRONE_SERVER_HOST=drone.organization.com \
  -e DRONE_SERVER_TOKEN=******************************** \
  -e DRONE_AGENT_TOKEN=******************************** \
  -e DRONE_AMAZON_TAGS=Proyect:drone-autoscaler,ResourceType:ec2-instance-drone-autoscaler,Proyect-Environment:droneapp-all-environment \
  -e DRONE_AMAZON_IMAGE=ami-07dd19a7900a1f049 \
  -e DRONE_AMAZON_VOLUME_TYPE=gp3 \
  -e DRONE_AGENT_CONCURRENCY=2 \
  -e DRONE_TLS_AUTOCERT=true \
  -e DRONE_AMAZON_VOLUME_SIZE=100 \
  -e DRONE_AGENT_IMAGE=drone/drone-runner-docker:1.8.2 \
  -e DRONE_AGENT_ENVIRON=DRONE_LOGS_DEBUG=true,DRONE_RUNNER_CAPACITY=2,DRONE_DEBUG=true,DRONE_REGISTRY_ENDPOINT=true,DRONE_RUNNER_NAME=localhost,DRONE_RPC_SECRET=********************************,DRONE_LOGS_PRETTY=true,DRONE_RPC_HOST=drone.organization.com,DRONE_LOGS_TRACE=true,DRONE_RPC_PROTO=https,DRONE_REGISTRY_ENDPOINT=http://drone.organization.com:3000,DRONE_REGISTRY_SECRET=******************************** \
  -e DRONE_AMAZON_INSTANCE=z1d.xlarge \
  -e DRONE_AMAZON_REGION=us-west-2 \
  -e DRONE_AMAZON_SUBNET_ID=subnet-******** \
  -e DRONE_AMAZON_SECURITY_GROUP=sg-***************** \
  -e DRONE_AMAZON_SSHKEY=ssh_key \
  -e AWS_ACCESS_KEY_ID=YOUR_AWS_ACCESS_KEY_ID \
  -e AWS_SECRET_ACCESS_KEY=YOUR_AWS_SECRET_ACCESS_KEY \
  -p 8080:8080 \
  --restart=always \
  --name=autoscaler \
  drone/autoscaler:1.8.2 

Aqui dejo una pequeña descripción de cada variable

DRONE_POOL_MIN: El mínimo de instancias activas
DRONE_POOL_MAX: El máximo de instancias activas
DRONE_INTERVAL: El intervalo de tiempo en el que se va a ir a revisar si hay algún proceso en la cola del drone
DRONE_POOL_MIN_AGE: El tiempo que va a vivir una instancia sin uso
DRONE_SERVER_TOKEN: El token de un usuario que sea admin
DRONE_AGENT_TOKEN: La respuesta del comando "openssl rand -hex 16"
DRONE_AMAZON_TAGS: Tags que se le van a atascar a las instancias creadas
DRONE_AMAZON_IMAGE: El id de una AMI
DRONE_AMAZON_VOLUME_TYPE: El tipo de volumen que van a tener las instancias
DRONE_AGENT_CONCURRENCY: Este es el número de procesos que va a correr como máximo una instancia
y después de esto ya debería estar escalando automáticamente
DRONE_AMAZON_VOLUME_SIZE: El tamaño del volumen
DRONE_AMAZON_INSTANCE: El tipo de instancia
DRONE_AMAZON_REGION: La región en donde se van a generar las instancias
DRONE_AMAZON_SUBNET_ID: El id de tu subnet preferida
DRONE_AMAZON_SECURITY_GROUP: El id de tu SG favorito
DRONE_AMAZON_SSHKEY: El ssh key de tu preferencia
AWS_ACCESS_KEY_ID: Un acces key id que tenga los permisos suficientes respecto a instancia
AWS_SECRET_ACCESS_KEY: El secret key de tu usuario
DRONE_AMAZON_IAM_PROFILE_ARN: Él role que se atascaran a las instancias
DRONE_AGENT_ENVIRON: Aqui podemos pasar cualquier variable y estas van a llegar a las instancias de los runners


Ahora ya tenemos todo listo, podemos mandar docker ps y ver que tenemos corriendo

Tenemos el autoscaler de drone, el servidor de drone y el registry-plugin de drone, este último se usa para poder inyectar variables globales por debajo a los procesos que corran en el drone.

Vamos a realizar una prueba.

Y después de unos dos minutos nuestra instancia va a estar levantada y el drone ya va a empezar a correr los procesos al drone

Y con esto ya tendríamos listo el autoscaler del drone, ahora una prueba que quiero hacer es crear una AMI propia, pero con el Docker y todo lo requerido para correr el Drone para bajar el tiempo de espera al levantar la máquina