Inicializando AWS CloudShell 2/3
Tags: aws, security, cloudskills, spanish
Published: 2021-03-30 16:31:21

# 👋 Hola

Antes de empezar a leer este blog, te recomiendo leer la primera parte de esta serie de 3 blogs.

{% link https://dev.to/aws-builders/inizializando-aws-cloudshell-1-3-40ba %}

## Ahora si, a lo nuestro 😉

Empezaremos iniciando CloudShell y haremos 2 ejercicios con AWS ECS que nos sirve para poder orquestar contenedores docker y finalizaremos con AWS Elastic Beanstalk que ayuda mucho a los desarrolladores a construir y desplegar sus aplicaciones sin entrar demasiado en terrenos de AWS 😼.

Una vez iniciado nuestro CloudShell, podemos escribir la siguiente sintaxis: 
~~~
ecs-cli configure --cluster micluster-docker --default-launch-type FARGATE --config-name micluster-docker
~~~

Esto dará lugar a que se cree y guarde un archivo de configuración para crear y lanzar posteriormente un clúster ECS de nombre `mi cluster-docker`, y nuestro clúster será del tipo `Fargate`.

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ofqv4mcqba6g91b5o36f.png)

Y si te das cuenta al inicio de la sintaxis dice `ecs-cli`.

### Entonces, ¿Qué significa todo esto? 🤔

Es cierto que hay varios términos aun desconocidos para algunos 
que puedan leer este blog, así que me aseguraré de hacer blogs dedicados a explicar estos temas.

### Pero de momento, conozcamos lo siguiente 💡:

- `ecs-cli` es una librería que nos permite poder crear, actualizar y administrar nuestros clústeres ECS desde una terminal.

- `Fargate` esto es magia pura, sencillamente es Severless para contenedores. Significa que no administras nada de hardware. Solo te dedicarías a desarrollar tus ambientes y subirlos a los contenedores.

## Creación de nuestro Clúster ECS

.1 Necesitaremos crear un IAM Role con un trust relationship para el servicio de ecs. Y Luego asignarle un IAM Policy que permita poder ejecutar tareas desde nuestro cluster.

 - Crearemos un `.json` en nuestro local con el siguiente contenido:
```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "ecs-tasks.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

 - Luego, subiremos este `.json` hacia nuestro cloudshell y ejecutaremos el siguiente comando para crear nuestro role:

`aws iam create-role --role-name ecsTaskExecutionRole --assume-role-policy-document file://task-execution-role.json`

- Aquí, la opcion para subir los archivos que necesitemos a nuestro cloudshell:
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d7wd0ddnm0ke3m4yaqtu.png)

 - Y ahora, debemos asignar una policy, recomiendo usar esta política administrada por AWS, pero puedes customizar tus acciones si crees necesario:

`aws iam attach-role-policy --role-name ecsTaskExecutionRole --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy`

.2 Ahora crearemos un cluster ECS Fargate:

`ecs-cli up --cluster-config micluster-docker`

 - Verás que adicionalmente se ha creado una nueva VPC y 2 subnets, cada uno de estos recursos con su ID, los cuales los necesitaremos mas adelante. Esto es opcional, tu puedes declarar en la sintaxis que el clúster se cree sobre una VPC existente.
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d2ey8zdd9u7eztgv4rqi.png)

- Vamos a necesitar poder recibir tráfico entrante hacia el puerto 80 (HTTP) desde internet. Para ello, ejecutaremos lo siguiente, remplaza el valor de `--group-id` por el que vas a utilizar:

`aws ec2 authorize-security-group-ingress --group-id sg-3829401103 --protocol tcp --port 80 --cidr 0.0.0.0/0`
 
## Ahora si se viene lo chido.jpg 🤣

.3 Crearemos nuestro archivo Docker Compose v3 que ya es soportado por `ecs-cli` con los siguientes parametros y lo guardaremos como `docker-compose.yml`

```yaml
version: '3'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    logging:
      driver: awslogs
      options: 
        awslogs-group: docker-logs
        awslogs-region: us-east-1
        awslogs-stream-prefix: ngnix
```

- En este pequeño archivo, estamos diciendo que se ejecute un `pull` de esa docker-image: `nginx-latest` que esta almacenada en Docker Hub. Y Luego hará un `push` hacia nuestro container instance para desplegar nuestra app la cual debe responder a través del puerto 80.

- Adicionalmente, se crea un grupo de registro en Cloudwatch para almacenar todos los logs provistos por nuestro clúster.

- También crearemos un archivo llamado `ecs-params.yml` para configurar los valores que tomarán nuestro task-definition e ecs-service:

```yaml
version: 1
task_definition:
  task_execution_role: ecsTaskExecutionRole
  ecs_network_mode: awsvpc
  task_size:
    mem_limit: 0.5GB
    cpu_limit: 256
run_params:
  network_configuration:
    awsvpc_configuration:
      subnets:
        - subnet-0cd9355ce5a8c5ea1
        - subnet-06194167d9bb4b593
      security_groups:
        - sg-038828235847fe023
      assign_public_ip: ENABLED
```

- Los valores que debes cambiar son `subnets` y `security groups`

.4 Llego el momento de configurar nuestro clúster ECS:

`ecs-cli compose --project-name miweb service up --create-log-groups --cluster-config micluster-docker --cluster micluster-docker --launch-type FARGATE`

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/02yhu642u6pto4n2wawu.png)

.5 En el paso anterior, obtuvimos en la ultima línea el mensaje de que nuestro ECS Service ya era estable 😃. Validemos que nuestro container-instance se encuentre en modo `running`:

`ecs-cli compose --project-name miweb service ps --cluster micluster-docker`
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9w2pb3p7sw7rd5845fsj.png)

.6 Tomemos la EIP o IP Pública que nos brinda el paso anterior y accedamos a ella desde nuestro navegador:

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/al9cbdsse90ysu7joe8j.png)
 
.7 En cuanto lo consideres, sugiero eliminar todos los recursos que hemos creado para que no incurran en costos:

- Este comando hara un stop a la instance-contanier que hemos creado:

`ecs-cli compose --project-name miweb service down --cluster micluster-docker`
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2sax0y0p7us6o4vz8t5p.png)
 
- Y Finalmente, este comando eliminara todo el contenido del cluster: 

`ecs-cli down --force --cluster-config micluster-docker`
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xy4xm4lmar4ayt61fnre.png)

- Adicionalmente, existirá un recurso aun pendiente de eliminar, y este es el task definition:

![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fid8x68mk1ym7kb55wph.png)

- Solo tienes que ingresar a este recurso, y dar en la opcion de `deregister`

 ![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fk9k2y0fx1vr3k083mm5.png)
 
- Podríamos hacer muchas mas cosas aquí, como agregar un ALB, un ASG, escalar nuestros nodos, usar Container Insights, etc, pero ya sería adentrarse en terrenos de ECS 😉. 

👋 Aquí paramos la tecla.