Desde hace algún tiempo estamos viendo cómo los servicios de computación serverless, donde [email protected] pueden centrarse en crear su aplicación y abstraerse de la infraestructura que hay debajo, no paran de crecer y aumentar en funcionalidad. Desde finales de 2017 tenemos a nuestra disposición AWS Fargate.

Fargate es un servicio que nos permite ejecutar contenedores en una infraestructura gestionada por AWS, sin tener que preocuparnos por las instancias que se ejecutarán. Además, su precio estará basado en el tiempo que nuestra tarea esté activa.

Además, desde el pasado AWS re-Invent tenemos a nuestra disposición Fargate Spot, que utiliza una infraestructura similar a la de las EC2 Spot instances, pudiendo ahorrar hasta un 70% de los costes en la ejecución de nuestras tareas.

Para entender cómo funciona este servicio y en qué casos podemos usarlo, veremos un pequeño ejemplo con un script en Python que ejecuta un “Hello World”.

 

¿Porqué deberías usar Fargate en lugar de Lambda?

¡Hablemos de costes!

Como hemos dicho, en el caso de Lambda los costes dependerán del tiempo que estemos ejecutando ciertos recursos.

En este caso, para las instancias on-demand en Irlanda (eu-west-1):

Y para las instancias Spot en Irlanda (eu-west-1):

Ahora que hemos visto los posibles casos de uso de Fargate y su precio, vamos a proceder con un pequeño tutorial de cómo lanzar nuestra primera tarea.

Los pasos son los siguientes:

  1. Crear un clúster de ECS
  2. Subir nuestra imagen de Docker a un ECR
  3. Crear la definición de la tarea
  4. Ejecutar la tarea

En el post encontraréis todos los pasos a ejecutar tanto desde la CLI de AWS, desde la consola y, en la medida de lo posible, tendréis a vuestra disposición stacks de CloudFormation de ejemplo en nuestro Github.

1. Creación del clúster

Para crear el clúster, lo primero que tendremos que especificar es la base desde la que queremos partir. En nuestro caso será “Networking Only”, ya que lo usaremos para tareas o servicios de Fargate.

Luego tendremos que darle un nombre para identificar el clúster, en caso de que queramos unos tags para dar contexto al recurso.

En caso de que queramos hacerlo desde la CLI, el comando equivalente a los pasos en la consola es el siguiente:

aws ecs create-cluster --cluster-name capside-blog-post --region eu-west-1

Y el output esperado es algo parecido a esto:

{
"cluster": {
"status": "ACTIVE",
"pendingTasksCount": 0,
"runningTasksCount": 0,
"statistics": [],
"clusterArn": "cluster-arn",
"clusterName": "capside-blog-post",
"registeredContainerInstancesCount": 0,
"activeServicesCount": 0
}
}

2. Crear y subir la imagen a un ECR

Para este post, asumiremos que [email protected] tenéis alguna experiencia con Docker y que podéis crear una imagen con vuestro servicio.

Una vez tengamos la imagen en nuestro Docker local, tenemos que subirla a algún repositorio de contenedores. Para la demo usaremos el ECR de AWS. Pero como hemos comentado, podéis utilizar el que queráis.

Los pasos son los siguientes:

1. Obtener las credenciales del ECR desde AWS

aws ecr get-login --region eu-west-1 > credenciales.txt

2. Autenticar contra el ECR

docker login -u AWS https://id_cuenta_aws.dkr.ecr.eu-west-1.amazonaws.com

3. Crear un repositorio

aws ecr create-repository --repository-name nuestro_servicio

4. Crear un tag de la imagen

docker tag nuestro_servicio:1.0 id_cuenta_aws.dkr.ecr.eu-west-1.amazonaws.com/nuestro_servicio:1.0

5. Subir la imagen al repositorio

docker push id_cuenta_aws.dkr.ecr.eu-west-1.amazonaws.com/ nuestro_servicio:1.0

3. Crear la definición de la tarea

Una vez tenemos un clúster dónde ejecutar nuestra tarea, y tenemos la imagen de Docker subida en un repositorio, procedemos a crear la definición de la tarea.

Primero, seleccionaremos el tipo de launch type que queremos para nuestra tarea. En nuestro caso, Fargate.

Aquí es donde definiremos las propiedades de la tarea. Debemos definir la cantidad de CPU y memoria que va a usar, la imagen, si queremos volúmenes o no, roles de acceso a recursos de AWS…

Primero configuraremos el nombre y el rol que queremos usar:

Una vez configurado esto, añadiremos el tamaño de la tarea. Es decir, la cantidad de memoria y CPU que va a usar:

Y finalmente la definición del contenedor, que es básicamente la imagen que vamos a usar.

Para hacerlo desde la consola, el comando equivalente sería el siguiente:

aws ecs register-task-definition --family Fargate --cpu 256 --memory 1024 --container-definitions '{ "name": "capside-blog-post-task", "image": " id_cuenta_aws.dkr.ecr.eu-west-1.amazonaws.com/ nuestro_servicio:1.0"}' --region eu-west-1

4. Ejecutar la tarea

Ahora que finalmente tenemos el clúster, la imagen y la definición de la tarea, solo queda ejecutarla.

Para ello, en el menú de ECS seleccionaremos “Run task” y configuraremos el Launch type, que en nuestro caso será Fargate. Seleccionaremos la definición de tarea que habíamos creado previamente y el clúster dónde queremos ejecutar la tarea.

Y con esto, ya tendríamos nuestra tarea en ejecución.

En este caso, el comando de la consola equivalente sería el siguiente:

aws ecs run-task --cluster capside-blog-post --task-definition capside-blog-post-task:1 --network-configuration awsvpcConfiguration={subnets=[subnet_id],securityGroups=[security_group_id],assignPublicIp=Enable} --region eu-west-1

TAGS: aws, cluster, docker, ECR, Fargate, Fargate Spot, Labs, serverless

speech-bubble-13-icon Created with Sketch.
Comentarios

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

*
*