Blog de Amazon Web Services (AWS)

Presentamos AWS Copilot

Por Nathan Peck, Developer Advocate AWS Elastic Containers.

 

La primera herramienta de línea de comandos oficial para Amazon Elastic Container Service (Amazon ECS) se creó en 2015. En diciembre de 2019, compartimos la versión preliminar de una nueva experiencia de línea de comandos, rediseñada desde cero para facilitar la implementación de su aplicaciones en Amazon ECS. Hoy, compartimos algunos de nuestros avances en esta herramienta de línea de comandos, así como su nuevo nombre oficial: AWS Copilot.

AWS Copilot está diseñado tanto para los usuarios nuevos de ECS como ya existentes, los cuales desean ir más allá de la administración manual de la infraestructura de bajo nivel  y comenzar a pensar en su aplicación y su ciclo de vida. Copilot crea implementaciones de aplicaciones modernas, basadas en patrones listos para producción que incluyen las mejores prácticas diseñadas por ingenieros y clientes de ECS a lo largo de los años.

Si está diseñando una nueva aplicación, probablemente comience con un diagrama mental que tenga recuadros para cada servicio y líneas sobre cómo se comunicarán entre sí. Pero más adelante, cuando llega el momento de crear esta arquitectura, hay muchos más componentes de la nube en los que pensar: subredes de Virtual Private Cloud (VPC), balanceadores de carga, flujos de implementación y almacenamiento persistente de su aplicación. Copilot maneja todos estos detalles subyacentes por usted. Simplemente proporcione su contenedor y deje que Copilot maneje las implementaciones de alta disponibilidad y la creación y configuración del balanceador de carga. Incluso puede hacer que Copilot cree un flujo  de implementación que volverá a implementar automáticamente la última versión de su aplicación cada vez que envíe una nueva confirmación a su repositorio de código.

En resumen, si usa Copilot, puede pasar de la idea a la implementación mucho más rápido, con la confianza de que la infraestructura que ha implementado tiene una configuración lista para producción.

 

Cómo instalar Copilot

Puede instalar AWS Copilot a través de Homebrew o descargando los binarios directamente.

Utilizando Homebrew

$ brew instalar aws/tap/copilot-cli

Manualmente

Si no desea utilizar Homebrew, puede instalarlo manualmente descargando la última versión de GitHub en su máquina de desarrollo.

Copie y pegue el comando en su terminal.

Mac

curl -Lo /usr/local/bin/copilot https://github.com/aws/copilot-cli/releases/download/v0.4.0/copilot-darwin-v0.4.0 && chmod +x /usr/local/bin/copilot && copilot --help

Linux

curl -Lo /usr/local/bin/copilot https://github.com/aws/copilot-cli/releases/download/v0.4.0/copilot-linux-v0.4.0 && chmod +x /usr/local/bin/copilot && copilot --help

Copilot utiliza las mismas credenciales que AWS CLI (Command Line Interface), por lo que si ya ha estado utilizando AWS CLI en su máquina de desarrollo, está listo para comenzar. Si aún no ha instalado o configurado AWS CLI, puede hacerlo siguiendo estas instrucciones. Asegúrese de ejecutar el comando aws configure después de instalar AWS CLI.

Por último, pero no menos importante, deberá asegurarse de que Docker esté instalado en su máquina de desarrollo. AWS Copilot utilizará Docker para crear y empaquetar su aplicación.

 

Introducción a los conceptos de Copilot

Primero, demos un vistazo rápido a los comandos de alto nivel disponibles en Copilot:

 

 

 

Copilot tiene tres conceptos principales:

  • Aplicación: una aplicación es un mecanismo de agrupación de las piezas de su sistema. Siguiendo la Ley de Conway, usted dividiría sus componentes en aplicaciones de tipo Copilot que correspondan a los diferentes equipos de desarrollo de su organización. Por ejemplo, si su organización es pequeña y cuenta con un equipo de desarrollo unificado que trabaja en un poco de todo, probablemente pueda organizar las cosas como una única aplicación compuesta por uno o más servicios. Pero si tiene varios equipos, cada uno responsable de un solo grupo de componentes, y por ende hay muy poco trabajo entre equipos, entonces cada equipo debe tener su propia aplicación Copilot.
  • Ambiente: un ambiente es una etapa del despliegue de una aplicación. Por ejemplo, primero puede implementar una aplicación en un ambiente de “control de calidad” para que pueda probarse sin afectar a sus clientes. Una vez que se ha verificado que funciona según lo previsto, usted desplegará esa versión de la aplicación en el ambiente de “producción” para que sus clientes puedan acceder a ella.
  • Servicio: un servicio es un proceso único de código de larga ejecución dentro de un contenedor. Una aplicación consta de uno o más servicios. Si está utilizando una arquitectura monolítica, es probable que cada aplicación tenga un solo servicio. Una arquitectura altamente distribuida utilizará múltiples servicios para cada aplicación. Por ejemplo, puede tener un servicio un sitio web con un balanceador de cargas con conexión a Internet, un servicio de “API” interno al que solo se pueda acceder mediante el descubrimiento de servicios y un servicio de trabajado en segundo plano que ejecuta  trabajos de una cola. Juntos, estos servicios conforman los componentes de una sola aplicación.

 

Iniciar con su primera aplicación en contenedores

El primer paso para cualquier aplicación en contenedores es el Dockerfile. El Dockerfile es un archivo pequeño que describe qué dependencias y archivos necesita su aplicación, así como qué programa ejecutar en el contenedor. Para este caso de ejemplo, usaremos NGINX, un servidor web estático simple para una aplicación de demostración, mi Dockerfile se verá así:

FROM nginx:alpine
EXPOSE 80
COPY . /usr/share/nginx/html

Este Dockerfile le dice a Docker que comience con un contenedor pre diseñado que ya tiene NGINX dentro, y luego agregaré archivos HTML al contenedor. También incluí una declaración  EXPOSE para que Copilot sepa qué puerto de aplicación necesita exponerse al mundo a través de un balanceador de carga.

A continuación, ejecutaré el siguiente comando  dentro del directorio de mi aplicación:

$ copilot init

 

 

Copilot encuentra automáticamente el Dockerfile que se usted escribió. Realiza algunas preguntas, cómo por ejemplo, si quiero nombrar la aplicación. Luego, creará un ambiente para implementar el servicio. Despues, construirá y envíara el contenedor a la nube. Por último, pero no menos importante, le proporcionará una URL donde puedo acceder a la aplicación.

 

Ahora que la aplicación está funcionando, puedo cargar la URL en mi navegador y enviar algunas solicitudes:

 

 

Después de realizar algunas solicitudes web a mis servicio NGINX en contenedores, puedo usar Copilot para ver los registros de mi aplicación ejecutando el siguiente comando en una terminal ssh:

 

$ copilot svc logs —follow

En este caso, mis registros de servicio son solo registros de acceso de NGINX, pero si estuviera ejecutando una aplicación, cualquier salida de depuración (debug) que imprimí en el flujo de salida estándar se mostraría aquí.

 

 

Implementar un entorno de producción

La primera aplicación que implemente en Copilot comenzará con la configuración predeterminada, que solo implementa un contenedor pequeño en AWS Fargate, un servicio de cluster de contenedores sin servidor que funciona tanto con Amazon Elastic Container Service (ECS) como con Amazon Elastic Kubernetes Service (EKS). Esta configuración está optimizada para un bajo costo y es ideal para propósitos de desarrollo, pero aún no está lista para el tráfico de producción.

 

Para prepararme para el tráfico de un ambiente tipo producción, necesitará configurar un nuevo ambiente. Ejecute el siguiente comando en una terminal ssh

 

$ copilot env init

 

 

Ahora, antes de implementar mi servicio en este ambiente de producción, necesito realizar algunos cambios en la configuración de este ambiente de producción. Puedo encontrar el archivo de manifiesto de configuración de mi servicio en la siguiente ruta: nombredeaplicacion/manifest.yml

 

Este archivo de manifiesto contiene todas las configuraciones predeterminadas para mi aplicación, como el puerto, cuánto CPU y memoria requiere y cuántas copias de la aplicación ejecutar. Cambiaremos estas configuraciones para el ambiente de producción agregando las siguientes declaraciones al archivo de manifiesto:

 

environments:
  production:
    count: 2
    cpu: 1024
    memory: 2048

Esto le dice a Copilot que cuando implemento mi aplicación en producción, quiero ejecutar dos copias de la aplicación, cada una con 1 CPU y 2 GB de memoria.

 

Ahora, puedo implementar el servicio en producción usando el comando:

 

$ copilot svc deploy —env production

 

 

 

Esta vez, Copilot implementa mi aplicación en el ambiente de producción como un conjunto de réplicas de alta disponibilidad distribuido en las zonas de disponibilidad, y cada contenedor tiene más CPU y memoria. Puedo ejecutar una prueba de carga simple usando ApacheBench para tener una idea de cuánto tráfico puede manejar esta implementación. Ejecute el siguiente comando en una terminal

 

ab -n 5000 -c 25 http://nyan-Publi-WI97060DJP1B-2041999651.us-east-1.elb.amazonaws.com

Este comando le dice a ApacheBench que haga 5000 solicitudes a mi servicio, con una concurrencia de 25 solicitudes a la vez.

 

Los resultados finales muestran 353 solicitudes por segundo muy aceptables, p99 de solo 165 ms y un tiempo promedio por solicitud de 70 ms.

 

Concurrency Level:    25

Time taken for tests: 14.140 seconds

Complete requests:    5000

Failed requests:      0

Total transferred:    7565000 bytes

HTML transferred:     6395000 bytes

Requests per second:  353.60 [#/sec] (mean)

Time per request:     70.701 [ms] (mean)

Time per request:     2.828 [ms] (mean, across all concurrent requests)

Transfer rate:        522.46 [Kbytes/sec] received




Connection Times (ms)

            min   mean[+/-sd]  median   max

Connect:    12     34   15.6     30     161

Processing: 14     37   16.1     34     334

Waiting:    14     36   16.1     33     334

Total:      32     70   23.1     65     402




Percentage of the requests served within a certain time (ms)

 50%     65

 66%     71

 75%     77

 80%     80

 90%     93

 95%    117

 98%    143

 99%    165

100%    402 (longest request)

 

Si decido que necesito soportar un tráfico más alto que este, puedo modificar fácilmente el manifiesto de mi aplicación para escalar horizontalmente aumentando el recuento de producción o escalar agregando más CPU a mi servicio y luego ejecutar el comando copilot svc deploy nuevamente.

 

Conclusión

Como puede ver, Copilot está diseñado para ayudarlo a implementar un servicio en contenedores listo para producción con solo unos pocos comandos. Usted proporciona su Dockerfile y deja que Copilot cree, envíe e inicie  su contenedor en AWS.

Pero este es solo el comienzo de las poderosas funciones de Copilot. Al usar Copilot, también obtiene una manera fácil de:

  • Configurar un flujo de CI / CD automáticamente para que pueda implementar simplemente sincronizando conun repositorio de Git
  • (Próximamente) Aprovisionar almacenamiento para sus servicios, incluidos buckets S3,bases de datos NoSQL y SQL

En un artículo futuro, profundizaremos en estas potentes funciones. Mientras tanto, envíenos sus comentarios o solicitudes de funciones en el repositorio oficial de GitHub del proyecto. ¡Las solicitudes de descarga también son bienvenidas!

Más información:

https://aws.amazon.com/blogs/containers/introducing-aws-copilot/

 

Este artículo fue traducido del Blog de AWS en Inglés.

 


Sobre el autor

Nathan Peck is a developer advocate for Elastic Container Service at Amazon Web Services. He focuses on highlighting the developer community that has embraced Amazon ECS, and connecting new developers to open source projects that can help them succeed at using ECS.

 

 

 

 

Sobre los traductores

 

Gabriel Gasca Torres es Solutions Architect  en AWS en México.

 

 

 

 

José Lorenzo Cuéncar es Solutions Architect  en AWS en México.