codepipeline codedeploy gradle amazon-s3 amazon-ec2 gitlab-ci aws-code-deploy

gradle - codedeploy - amazon s3



Cómo implementar con Gitlab-Ci a EC2 utilizando AWS CodeDeploy/CodePipeline/S3 (1)

He creado un conjunto de archivos de muestra para ir con la Guía que se proporciona a continuación. Estos archivos están disponibles en el siguiente enlace: https://gitlab.com/autronix/gitlabci-ec2-deployment-samples-guide/

Alcance

Esta guía asume lo siguiente

  • Proyecto alojado Gitlab EE: puede funcionar en instancias privadas de CE / EE (no probado)
  • Gitlab como el repositorio de versiones GIT
  • Gitlab-CI como el motor de integración continua
  • Cuenta de AWS existente
  • AWS EC2 como el sistema de producción o de almacenamiento objetivo para el despliegue
  • Instancia de AWS EC2 que ejecuta AMI de Amazon Linux
  • AWS S3 como instalación de almacenamiento para archivos de implementación
  • AWS CodeDeploy como motor de implementación para el proyecto
  • AWS CodePipeline como Pipeline para la implementación

La muestra .gitlab-ci.yml proporcionada se basa en un proyecto Java / Scala + Gradle. La secuencia de comandos se proporciona como un ejemplo genérico y deberá adaptarse a sus necesidades específicas al implementar la entrega continua a través de este método.

La guía asumirá que el usuario tiene conocimientos básicos sobre los servicios de AWS y cómo realizar las tareas necesarias.

Nota : la guía proporcionada en este ejemplo utiliza la consola de AWS para realizar tareas. Si bien es probable que la CLI sea equivalente para las tareas que se realizan aquí, estas no se cubrirán en toda la guía.

Motivación

La motivación para crear estos scripts y la guía de implementación provino de la falta de disponibilidad de un tutorial adecuado que muestre cómo implementar la entrega continua utilizando Gitlab y AWS EC2. Gitlab presentó su motor de CI de libre acceso al asociarse con Digital Ocean, lo que permite a los repositorios de usuarios beneficiarse de CI de buena calidad de forma gratuita.

Una de las principales ventajas de usar Gitlab es que proporcionan contenedores de integración continua incorporados para ejecutar los distintos pasos y validar una compilación. Desafortunadamente, Gitblab ni AWS proporcionan una integración que permitiría realizar la entrega continua después de las compilaciones aprobadas.

Esta guía y los scripts ( https://gitlab.com/autronix/gitlabci-ec2-deployment-samples-guide/ ) proporcionan una versión simplificada de los pasos que he emprendido para tener un CI y un CD exitosos con Gitlab. y AWS EC2 que puede ayudar a cualquier persona a comenzar con este tipo de implementación.

Configuración del entorno en AWS

El primer paso para garantizar un proceso de entrega continua exitoso es configurar los objetos necesarios en AWS para permitir que el proceso de implementación tenga éxito.

Usuario AWS IAM

El requisito inicial será configurar un usuario de IAM:

https://console.aws.amazon.com/iam/home?#users

  1. Crear un usuario

  2. Adjunte los siguientes permisos:

    • CodePipelineFullAccess
    • AmazonEC2FullAccess
    • AmazonS3FullAccess
    • AWSCodeDeployFullAccess
    • Política en línea: {"Versión": "2012-10-17", "Declaración": [{"Efecto": "Permitir", "Acción": ["autoescalado: ", "codedeploy: ", "ec2: ", "elasticloadbalancing: ", "iam: AddRoleToInstanceProfile", "iam: CreateInstanceProfile", "iam: CreateRole", "iam: DeleteInstanceProfile", "iam: DeleteRole", "iam: DeleteRolePolicy", "iam: GetInstanceProfile" ", iam: DeleteRolePolicy", "iam: GetInstanceProfile" "," GetRole "," iam: GetRolePolicy "," iam: ListInstanceProfilesForRole "," iam: ListRolePolicies "," iam: ListRoles "," iam: PassRole "," iam: PutRolePolicy "," iam: RemoveRoleFromInstanceProfile "" "" "" " , "Recurso": " "}]}

  3. Generar credenciales de seguridad.

Nota : Las políticas enumeradas anteriormente tienen un alcance muy amplio. Puede ajustarse a sus requisitos creando políticas personalizadas que limitan el acceso solo a ciertos recursos.

Nota : Guarde estas credenciales en un lugar seguro. Los necesitarás en un paso posterior.

AWS EC2, instancia y rol

Rol de instancia para CodeDeploy

https://console.aws.amazon.com/iam/home?region=us-east-1#roles

Cree un nuevo rol que se asignará a su instancia de EC2 para acceder a S3,

  1. Establezca el nombre de acuerdo con sus convenciones de nomenclatura (es decir, MyDeploymentAppRole )
  2. Seleccione Amazon EC2 para permitir que las instancias de EC2 ejecuten otros servicios de AWS
  3. Adjuntar las siguientes políticas:
    • AmazonEC2FullAccess
    • AmazonS3FullAccess
    • AmazonCodeDeployRole

Nota : Las políticas enumeradas anteriormente tienen un alcance muy amplio. Puede ajustarse a sus requisitos creando políticas personalizadas que limitan el acceso solo a ciertos recursos.

Instancia de lanzamiento

https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#

Haga clic en Launch Instance y siga estos pasos:

  • Seleccione Amazon Linux AMI 2016.03.3 (HVM), SSD Volume Type
  • Seleccione el tipo de instancia requerido (t2.micro por defecto)
    • Siguiente
  • Seleccione IAM Role para que sea MyDeploymentAppRole (según el nombre creado en la sección anterior)
    • Siguiente
  • Seleccione el almacenamiento apropiado
    • Siguiente
  • Etiquete su instancia con un nombre apropiado (es decir, MyApp-Production-Instance )
    • agregar etiquetas adicionales según sea necesario
    • Siguiente
  • Configure el grupo de seguridad según sea necesario
    • Siguiente
  • Revisa y lanza tu instancia

Se le proporcionará la posibilidad de generar o utilizar claves SSH. Por favor seleccione el método apropiado apropiado.

Configuración del entorno de instancia

Instale CodeDeploy Agent

Inicie sesión en su instancia EC2 recién creada y siga las instrucciones:

CodeDeploy rutas importantes:

  • CodeDeploy Directorio de base de implementación: /opt/codedeploy-agent/deployment-root/
  • Archivo de registro de CodeDeploy: /var/log/aws/codedeploy-agent/codedeploy-agent.log

Consejo : ejecute tail -f /var/log/aws/codedeploy-agent/codedeploy-agent.log para realizar un seguimiento de la implementación en tiempo real.

Instale los requisitos previos de su proyecto Si su proyecto tiene requisitos previos para ejecutar, asegúrese de instalarlos antes de ejecutar la implementación, de lo contrario su secuencia de comandos de inicio puede fallar.

Repositorio AWS S3

https://console.aws.amazon.com/s3/home?region=us-east-1

En este paso, deberá crear un grupo de S3 que contendrá sus archivos de implementación.

Simplemente siga estos pasos:

  1. Elija Create Bucket
    • Seleccione un nombre de cubo (es decir, my-app-codepipeline-deployment )
    • Seleccione una región
  2. En la consola para su cubo seleccione Properties
    • Expandir el menú de Versioning
    • elija Enable Versioning

Código de implementación de AWS

https://console.aws.amazon.com/codedeploy/home?region=us-east-1#/applications

Ahora que los elementos básicos están configurados, estamos listos para crear la aplicación de implementación en CodeDeploy

Para crear una aplicación de implementación de CodeDeploy, siga estos pasos:

  1. Seleccione Create New Application
  2. Elija un nombre de aplicación (es decir, MyApp-Production )
  3. Elija un nombre de grupo de implementación (es decir, MyApp-Production-Fleet )
  4. Seleccione las instancias de EC2 que se verán afectadas por esta implementación - Search by Tags
    • Bajo el Name selección de Key
    • Bajo Value Seleccione MyApp-Production-Instance
  5. En Service Role , seleccione MyDeploymentAppRole
  6. Haga clic en Create Application

Nota : puede asignar la implementación a cualquier etiqueta relevante que se aplique a las instancias deseadas dirigidas a la implementación. Para simplificar, solo se ha usado la etiqueta de nombre para elegir la instancia previamente definida.

Código de AWS

https://console.aws.amazon.com/codepipeline/home?region=us-east-1#/dashboard

El siguiente paso es continuar con la creación de CodePipeline, que se encarga de realizar la conexión entre el grupo S3 y el proceso de CodeDeploy.

Para crear un CodePipeline, sigue estos pasos:

  1. Haga clic en Create Pipeline
  2. Asigne un nombre a su canalización (es decir, MyAppDeploymentPipeline )
    • Siguiente
  3. Establecer el Source Provider para Amazon S3
    • establezca Amazon S3 location en la dirección de su contenedor y el archivo de implementación de destino (es decir, s3://my-app-codepipeline-deployment/myapp.zip )
    • Siguiente
  4. Establezca Build Provider en None : esto ya lo maneja Gitlab-CI como se tratará más adelante
    • Siguiente
  5. Establecer el Deployment Provider en AWS CodeDeploy
    • establezca el nombre de la aplicación al nombre de su aplicación CodeDeploy (es decir, MyApp-Production )
    • establezca el Deployment Group con el nombre de su Grupo de implementación de CodeDeploy (es decir, MyApp-Production-Fleet )
    • Siguiente
  6. Crear o elegir una función de servicio de canalización
    • Siguiente
  7. Revise y haga clic en Create Pipeline

Configurando el entorno en Gitlab

Ahora que el entorno de AWS se ha preparado para recibir la implementación de la aplicación, podemos continuar con la configuración del entorno y la configuración de CI para garantizar que el código se genere y se implemente en una instancia de EC2 mediante S3, CodeDeploy y CodePipeline.

Variables de Gitlab

Para que la implementación funcione, necesitaremos establecer algunas variables de entorno en el repositorio del proyecto.

En su Proyecto Gitlab, navegue al área de Variables para su proyecto y establezca las siguientes variables:

  • AWS_DEFAULT_REGION => su región de AWS
  • AWS_SECRET_ACCESS_KEY => su clave secreta de credencial de usuario de AWS (obtenida cuando generó las credenciales para el usuario)
  • AWS_ACCESS_KEY_ID => su ID de clave de credencial de usuario de AWS (obtenida cuando generó las credenciales para el usuario)
  • AWS_S3_LOCATION => la ubicación de su archivo zip de implementación (es decir, s3://my-app-codepipeline-deployment/my_app.zip )

Se podrá acceder a estas variables mediante los scripts ejecutados por los contenedores Gitlab-CI.

Guión de inicio

Se ha proporcionado un sencillo script de inicio ( https://gitlab.com/autronix/gitlabci-ec2-deployment-samples-guide/blob/master/deploy/extras/my_app.sh ) para permitir que la implementación realice las siguientes tareas:

  • Inicie la aplicación y cree un archivo PID
  • Compruebe el estado de la aplicación a través del archivo PID
  • Detener la aplicación

Puede encontrar este script en deploy/extras/my_app.sh

Creando gitlab-ci.yml

El archivo gitlab-ci.yml se encarga de realizar las tareas de integración continua asociadas con un compromiso dado. Actúa como un grupo simplificado de shell scripts que se organizan en etapas que corresponden a las diferentes fases en sus pasos de integración continua.

Para obtener más información sobre los detalles y la referencia, consulte los siguientes dos enlaces:

Puede validar la sintaxis de su archivo gitlab-ci.yml en cualquier momento con la siguiente herramienta: https://gitlab.com/ci/lint

Para el propósito de la implementación, cubriremos solo la última parte de la muestra provista con esta guía:

deploy-job: # Script to run for deploying application to AWS script: - apt-get --quiet install --yes python-pip # AWS CLI requires python-pip, python is installed by default - pip install -U pip # pip update - pip install awscli # AWS CLI installation - $G build -x test -x distTar # # Build the project with Gradle - $G distZip # creates distribution zip for deployment - aws s3 cp $BUNDLE_SRC $AWS_S3_LOCATION # Uploads the zipfile to S3 and expects the AWS Code Pipeline/Code Deploy to pick up # requires previous CI stages to succeed in order to execute when: on_success stage: deploy environment: production cache: key: "$CI_BUILD_NAME/$CI_BUILD_REF_NAME" untracked: true paths: - build/ # Applies only to tags matching the regex: ie: v1.0.0-My-App-Release only: - /^v/d+/./d+/./d+-.*$/ except: - branches - triggers

Esta parte representa todo el trabajo asociado con la implementación después de las etapas de CI anteriores, si las hubiera.

La parte relevante asociada con el despliegue es esta:

# Script to run for deploying application to AWS script: - apt-get --quiet install --yes python-pip # AWS CLI requires python-pip, python is installed by default - pip install -U pip # pip update - pip install awscli # AWS CLI installation - $G build -x test -x distTar # # Build the project with Gradle - $G distZip # creates distribution zip for deployment - aws s3 cp $BUNDLE_SRC $AWS_S3_LOCATION # Uploads the zipfile to S3 and expects the AWS Code Pipeline/Code Deploy to pick up

El primer paso consiste en instalar el sistema de administración de paquetes python: pip . se requiere pip para instalar AWS CLI, que es necesario para cargar el archivo de implementación en AWS S3

En este ejemplo, estamos usando Gradle (definido por la variable de entorno $G ); Gradle proporciona un módulo para comprimir automáticamente los archivos de implementación. Dependiendo del tipo de proyecto que esté implementando, este método será diferente para generar el archivo zip de distribución my_app.zip .

El comando aws s3 cp $BUNDLE_SRC $AWS_S3_LOCATION carga el archivo zip de distribución en la ubicación de Amazon S3 que definimos anteriormente. Luego, CodePipeline detecta este archivo, lo procesa y lo envía a CodeDeploy. Finalmente, CodeDeploy realiza las tareas necesarias a través del agente de CodeDeploy según lo especificado por el archivo appspec.yml .

Creando appspec.yml

appspec.yml define el comportamiento que debe seguir CodeDeploy una vez que se haya recibido un archivo de implementación.

Se ha proporcionado un archivo de muestra junto con esta guía junto con los scripts de muestra que se ejecutarán durante las distintas fases de la implementación.

Consulte la especificación de CodeDeploy AppSpec para obtener más información sobre cómo crear el archivo appspec.yml : http://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html

Generando el archivo zip de implementación

Para que CodeDeploy funcione correctamente, debe crear un archivo zip correctamente generado de su aplicación.

El archivo zip debe contener:

  • Raíz zip
    • appspec.yml => CodeDeploy instrucciones de implementación
    • guiones de la etapa de despliegue
    • los ejemplos proporcionados se colocarán en el directorio de scripts en el archivo zip, requerirán que se my_app.sh script my_app.sh presencia en la raíz del directorio de su aplicación (es decir, el directorio my_app en el zip)
    • Código de distribución: en nuestro ejemplo, estaría bajo el directorio my_app

Herramientas como Gradle y Maven son capaces de generar archivos zip de distribución con ciertas alteraciones en el proceso de generación de zip. Si no utiliza una herramienta de este tipo, es posible que deba indicar a Gitlab-CI que genere este archivo zip de una manera diferente; Este método está fuera del alcance de esta guía.

Desplegando su aplicación a EC2

El paso final en esta guía es realizar una implementación exitosa.

Las etapas de la integración continua están definidas por las reglas establecidas en gitlab-ci.yml . El ejemplo proporcionado con esta guía iniciará una implementación para cualquier referencia que coincida con la siguiente expresión regular: /^v/d+/./d+/./d+-.*$/ .

En este caso, si presiona una etiqueta v1.0.0-My-App-Alpha-Release través de git en su Gitlab remoto, se iniciará el proceso de implementación. Puede ajustar estas reglas según corresponda a los requisitos de su proyecto.

El gitlab-ci.yml proporcionado realizaría los siguientes trabajos al detectar la etiqueta v1.0.0-My-App-Alpha-Release :

  • construir trabajo - compilar las fuentes
  • trabajo de prueba - ejecutar las pruebas de la unidad
  • deploy-job: compile las fuentes, genere el código postal de distribución, cargue el archivo zip en Amazon S3

Una vez que el archivo zip de distribución se ha cargado en Amazon S3, suceden los siguientes pasos:

  • CodePipeline detecta el cambio en la revisión del archivo zip S3
  • CodePipeline valida el archivo
  • CodePipeline envía una señal de que el paquete para CodeDeploy está listo
  • CodeDeploy ejecuta los pasos de implementación
    • Inicio - inicialización del despliegue
    • Application Stop - Ejecuta el script definido para el gancho
    • DownloadBundle: obtiene el archivo de paquete del repositorio de S3 a través de CodePipeline
    • BeforeInstall - Ejecuta el script definido para el gancho
    • Instalar: copia el contenido a la ubicación de implementación como se define en la sección de files de appspec.yml
    • AfterInstall - Ejecuta el script definido para el gancho
    • ApplicationStart - Ejecuta el script definido para el gancho
    • ValidateService - Ejecuta el script definido para el gancho
    • Fin: indica al CodePipeline que la implementación se ha completado correctamente.

Capturas de pantalla de despliegue exitoso:

Referencias

He estado trabajando en un proyecto SlackBot basado en Scala usando Gradle y he estado buscando formas de aprovechar Gitlab-CI con el propósito de implementarlo en AWS EC2.

Soy capaz de compilar y probar completamente mi aplicación con Gitlab-CI.

¿Cómo puedo realizar una implementación de Gitlab-CI a Amazon EC2 usando CodeDeploy y CodePipeline?

Responder a seguir como una guía para hacer esto.