Cómo añadir CI/CD a mi proyecto SAM
Te mostraré cómo puedes desplegar un proyecto SAM con AWS CodePipeline usando la integración de pipeline incluida en el CLI de AWS SAM.
AWS SAM
Guía completa de AWS Serverless Application Model (SAM) para construir, probar y desplegar aplicaciones serverless.
3 articles
TLDR
Usaremos sam pipeline para desplegar la solución.
Tuve que crear
una plantilla personalizadapara poder desplegar la soluciónusando solo 1 etapa. Usando las plantillas predeterminadas tienes que usar 2, y no quiero hacerlo para este PoC. Este es el código de GitHub de mi plantilla personalizada
Introducción
Añadiremos CI/CD a nuestra aplicación SAM a través de la integración de pipeline del CLI de AWS SAM.
Como queremos añadir automatización a nuestro proceso de despliegue e integrarlo con el ecosistema de AWS, usaremos las herramientas de desarrollo de AWS (CodePipeline y CodeBuild). Para el repositorio Git, usaré GitHub.
Este es el código del proyecto SAM en GitHub que usaremos en el artículo. En el historial de commits puedes encontrar la evolución de la aplicación a través de los pasos explicados.
1. Añadir CI/CD a un proyecto SAM
Crearemos el pipeline CI/CD para implementar despliegue continuo, así que cuando hagamos push de nuevo código, el pipeline desplegará nuestros recursos automáticamente.
De la documentación de AWS: AWS SAM proporciona un conjunto de
plantillas de pipeline predeterminadaspara múltiples sistemas CI/CD que encapsulan las mejores prácticas de despliegue de AWS. Estas plantillas de pipeline predeterminadas usan formatos de configuración de pipeline JSON/YAML estándar, y las mejores prácticas integradas ayudan a realizar despliegues multi-cuenta y multi-región y verificar que los pipelines no puedan hacer cambios no intencionados a la infraestructura.
Queremos crear un nuevo pipeline en el recurso AWS CodePipeline usando las plantillas SAM.
Para generar el pipeline para AWS CodePipeline, tenemos que realizar las siguientes tareas en este orden:
- Crear recursos de infraestructura
- Generar la configuración del pipeline
- Hacer commit de la configuración del pipeline al repositorio Git
- Desplegar el pipeline
- Conectar el repositorio Git con el sistema CI/CD
Después de que hayas generado la configuración inicial del pipeline y la hayas commiteado a tu repositorio Git, cada vez que alguien haga commit de un cambio de código a ese repositorio, tu pipeline se activará para desplegar los nuevos cambios automáticamente.
Paso 1: Crear recursos de infraestructura (bootstrap)
Los Pipelines que usan AWS SAM requieren ciertos recursos AWS, como un usuario IAM y roles con los permisos necesarios, un bucket de Amazon S3 y opcionalmente un repositorio de Amazon ECR. Debes tener un conjunto de recursos de infraestructura para cada etapa de despliegue del pipeline.
Entonces, para cada etapa que necesitemos (dev, test, prod…), tenemos que ejecutar sam pipeline bootstrap. Este comando creará un stack de CloudFormation con el nombre aws-sam-cli-managed-${stage}-pipeline-resources con los recursos necesarios que SAM necesita.
Crearemos una sola etapa con el nombre test:
1
sam pipeline bootstrap
Haz clic para ver la salida del comando
sam pipeline bootstrap generates the required AWS infrastructure resources to connect
to your CI/CD system. This step must be run for each deployment stage in your pipeline,
prior to running the sam pipeline init command.
We will ask for [1] stage definition, [2] account details, and
[3] references to existing resources in order to bootstrap these pipeline resources.
[1] Stage definition
Enter a configuration name for this stage. This will be referenced later when you use the sam pipeline init command:
Stage configuration name: > test
[2] Account details
The following AWS credential sources are available to use.
To know more about configuration AWS credentials, visit the link below:
https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html
1 - Environment variables
2 - default (named profile)
3 - localstack (named profile)
q - Quit and configure AWS credentials
Select a credential source to associate with this stage: > 1
Associated account 00000000000 with configuration test.
Enter the region in which you want these resources to be created [eu-west-1]:
Select a user permissions provider:
1 - IAM (default)
2 - OpenID Connect (OIDC)
Choice (1, 2): 1
Enter the pipeline IAM user ARN if you have previously created one, or we will create one for you []:
[3] Reference application build resources
Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []:
Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []:
Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []:
Does your application contain any IMAGE type Lambda functions? [y/N]:
[4] Summary
Below is the summary of the answers:
1 - Account: 00000000000
2 - Stage configuration name: test
3 - Region: eu-west-1
4 - Pipeline user: [to be created]
5 - Pipeline execution role: [to be created]
6 - CloudFormation execution role: [to be created]
7 - Artifacts bucket: [to be created]
8 - ECR image repository: [skipped]
Press enter to confirm the values above, or select an item to edit the value:
This will create the following required resources for the 'test' configuration:
- Pipeline IAM user
- Pipeline execution role
- CloudFormation execution role
- Artifact bucket
Should we proceed with the creation? [y/N]: y
Creating the required resources...
Successfully created!
The following resources were created in your account:
- Pipeline execution role
- CloudFormation execution role
- Artifact bucket
- Pipeline IAM user
Pipeline IAM user credential:
AWS_ACCESS_KEY_ID: xxxxxxxxxx
AWS_SECRET_ACCESS_KEY: xxxxxxxxxx
View the definition in .aws-sam/pipeline/pipelineconfig.toml,
run sam pipeline bootstrap to generate another set of resources, or proceed to
sam pipeline init to create your pipeline configuration file.
Before running sam pipeline init, we recommend first setting up AWS credentials
in your CI/CD account. Read more about how to do so with your provider in
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-generating-example-ci-cd-others.html.
Se crea un nuevo stack para nuestra nueva etapa test.
Si quieres más de 1 etapa debes repetir el
sam pipeline bootstrappara la nueva etapa (¿prod?). En este ejemplo solo quiero 1 etapa para simplificar.
En nuestro proyecto SAM ahora tenemos 1 nuevo archivo que contiene la información de nuestra etapa:
Paso 2: Generar la configuración del pipeline
Plantilla de pipeline de dos etapas
Para generar la configuración del pipeline, ejecuta el comando sam pipeline init:
1
sam pipeline init
Haz clic para ver la salida del comando
sam pipeline init generates a pipeline configuration file that your CI/CD system
can use to deploy serverless applications using AWS SAM.
We will guide you through the process to bootstrap resources for each stage,
then walk through the details necessary for creating the pipeline config file.
Please ensure you are in the root folder of your SAM application before you begin.
Select a pipeline template to get started:
1 - AWS Quick Start Pipeline Templates
2 - Custom Pipeline Template Location
Choice: > 1
Cloning from https://github.com/aws/aws-sam-cli-pipeline-init-templates.git (process may take a moment)
Select CI/CD system
1 - Jenkins
2 - GitLab CI/CD
3 - GitHub Actions
4 - Bitbucket Pipelines
5 - AWS CodePipeline
Choice: > 5
You are using the 2-stage pipeline template.
_________ _________
| | | |
| Stage 1 |->| Stage 2 |
|_________| |_________|
Checking for existing stages...
Only 1 stage(s) were detected, fewer than what the template requires: 2.
To set up stage(s), please quit the process using Ctrl+C and use one of the following commands:
sam pipeline init --bootstrap To be guided through the stage and config file creation process.
sam pipeline bootstrap To specify details for an individual stage.
To reference stage resources bootstrapped in a different account, press enter to proceed []:
What is the Git provider?
1 - Bitbucket
2 - CodeCommit
3 - GitHub
4 - GitHubEnterpriseServer
Choice []: > 3
What is the full repository id (Example: some-user/my-repo)?: alazaroc/aws-sam-app
What is the Git branch used for production deployments? [main]:
What is the template file path? [template.yaml]:
We use the stage configuration name to automatically retrieve the bootstrapped resources created when you ran `sam pipeline bootstrap`.
Here are the stage configuration names detected in .aws-sam/pipeline/pipelineconfig.toml:
1 - test
Select an index or enter the stage 1's configuration name (as provided during the bootstrapping): 1
What is the sam application stack name for stage 1? [sam-app]:
Stage 1 configured successfully, configuring stage 2.
Here are the stage configuration names detected in .aws-sam/pipeline/pipelineconfig.toml:
1 - test
Select an index or enter the stage 2's configuration name (as provided during the bootstrapping):
Select an index or enter the stage 2's configuration name (as provided during the bootstrapping):
Tengo que detener la ejecución aquí.
En el log de consola a continuación, se muestra lo siguiente:
- You are using the 2-stage pipeline template
- Only 1 stage(s) were detected, fewer than what the template requires: 2.
En cualquier proyecto real deberías tener al menos dos etapas, así que podrías usar la plantilla predeterminada de AWS.
Sin embargo, no quiero crear dos etapas en mi pipeline CI/CD, estoy probando un proyecto SAM simple, y solo quiero UNA.
Desafortunadamente, no puedes hacer eso con las
AWS Quick Start Pipeline Templatesasí que hice fork del proyecto principal de AWS y creé una plantilla personalizada con solo UNA etapa.Este es mi proyecto forkeado: https://github.com/alazaroc/aws-sam-cli-pipeline-init-templates.git
Tuve que poner mi plantilla personalizada en la carpeta raíz porque de lo contrario, el CLI de AWS SAM no funciona.
Plantilla de pipeline de una etapa
En la siguiente ejecución, seleccionaré la opción Custom Pipeline Template Location y usaré mi repositorio forkeado actualizado para crear solo una etapa en el servicio AWS CodePipeline.
1
sam pipeline init
Haz clic para ver la salida del comando
sam pipeline init generates a pipeline configuration file that your CI/CD system
can use to deploy serverless applications using AWS SAM.
We will guide you through the process to bootstrap resources for each stage,
then walk through the details necessary for creating the pipeline config file.
Please ensure you are in the root folder of your SAM application before you begin.
Select a pipeline template to get started:
1 - AWS Quick Start Pipeline Templates
2 - Custom Pipeline Template Location
Choice: 2
Template Git location: https://github.com/alazaroc/aws-sam-cli-pipeline-init-templates.git
Cloning from https://github.com/alazaroc/aws-sam-cli-pipeline-init-templates.git (process may take a
moment)
You are using the 1-stage pipeline template.
_________
| |
| Stage 1 |
|_________|
Checking for existing stages...
1 stage(s) were detected, matching the template requirements. If these are incorrect, delete .aws-sam/pipeline/pipelineconfig.toml and rerun
What is the Git provider?
1 - Bitbucket
2 - CodeCommit
3 - GitHub
4 - GitHubEnterpriseServer
Choice []: 3
What is the full repository id (Example: some-user/my-repo)?: alazaroc/aws-sam-app
What is the Git branch used for production deployments? [main]:
What is the template file path? [template.yaml]:
We use the stage name to automatically retrieve the bootstrapped resources created when you ran `sam pipeline bootstrap`.
Here are the stage configuration names detected in .aws-sam/pipeline/pipelineconfig.toml:
1 - test
What is the name of stage (as provided during the bootstrapping)?
Select an index or enter the stage name: 1
What is your sam application stack name? [sam-app]:
What is the S3 bucket name used for artifacts of SAM deployments? Not the ARN, the name. [aws-sam-cli-managed-test-pipeline--artifactsbucket-gro48levpwla]: aws-sam-cli-managed-test-pipeline--artifactsbucket-gro48levpwla
What is the prefix of the S3 bucket used for artifacts of SAM deployments? []:
Stage configured successfully (you only have one stage).
To deploy this template and connect to the main git branch, run this against the leading account:
`sam deploy -t codepipeline.yaml --stack-name <stack-name> --capabilities=CAPABILITY_IAM`.
SUMMARY
We will generate a pipeline config file based on the following information:
What is the Git provider?: GitHub
What is the full repository id (Example: some-user/my-repo)?: alazaroc/aws-sam-app
What is the Git branch used for production deployments?: main
What is the template file path?: template.yaml
What is the name of stage (as provided during the bootstrapping)?
Select an index or enter the stage name: 1
What is your sam application stack name?: sam-app
What is the pipeline execution role ARN for this stage?: arn:aws:iam::00000000000:role/aws-sam-cli-managed-test-pipe-PipelineExecutionRole-Fv4wReTqFrHy
What is the CloudFormation execution role ARN for this stage?: arn:aws:iam::00000000000ole/aws-sam-cli-managed-test--CloudFormationExecutionRo-4iXZtj3Xzch9
What is the S3 bucket name used for artifacts of SAM deployments? Not the ARN, the name.: aws-sam-cli-managed-test-pipeline--artifactsbucket-gro48levpwla
What is the prefix of the S3 bucket used for artifacts of SAM deployments?:
What is the ECR repository URI for this stage?:
What is the AWS region?: eu-west-1
Successfully created the pipeline configuration file(s):
- codepipeline.yaml
- assume-role.sh
- pipeline/buildspec_unit_test.yml
- pipeline/buildspec_build_package.yml
- pipeline/buildspec_integration_test.yml
- pipeline/buildspec_feature.yml
- pipeline/buildspec_deploy.yml
Ahora tenemos los nuevos archivos en nuestro proyecto que CodePipeline usará para desplegar nuestro código:
Paso 3: Hacer commit de la configuración del pipeline a Git
Este paso asegura que tu sistema CI/CD reconozca tu configuración de pipeline y active despliegues al hacer commits de código.
Paso 4: Desplegar el pipeline
Para AWS CodePipeline tienes que desplegar el pipeline ejecutando sam deploy -t codepipeline.yaml --stack-name <pipeline-stack-name> --capabilities=CAPABILITY_IAM --region <region-X>
No establezcas el mismo nombre de stack que tu aplicación SAM porque hacerlo sobrescribirá el stack de tu aplicación (y eliminará los recursos de tu aplicación).
1
sam deploy -t codepipeline.yaml --stack-name pipeline-sam-app --capabilities=CAPABILITY_IAM
Haz clic para ver la salida del comando
Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-k2z3x0eqvuxq
A different default S3 bucket can be set in samconfig.toml
Or by specifying --s3-bucket explicitly.
Deploying with following values
===============================
Stack name : pipeline-sam-app
Region : eu-west-1
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisourcebucket-k2z3x0eqvuxq
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to sam-app/1ac2fdc178c63ba988480068fe211880.template 15696 / 15696 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
-----------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-----------------------------------------------------------------------------------------------------
+ Add CodeBuildProjectBuildAn AWS::CodeBuild::Project N/A
dPackage
+ Add CodeBuildProjectDeploy AWS::CodeBuild::Project N/A
+ Add CodeBuildServiceRole AWS::IAM::Role N/A
+ Add CodePipelineExecutionRo AWS::IAM::Role N/A
le
+ Add CodeStarConnection AWS::CodeStarConnection N/A
s::Connection
+ Add PipelineStackCloudForma AWS::IAM::Role N/A
tionExecutionRole
+ Add Pipeline AWS::CodePipeline::Pipe N/A
line
-----------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:eu-west-1:00000000000:changeSet/samcli-deploy1706135069/11d2764f-90e7-4495-b70c-513533ce61d2
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: > y
2024-01-24 23:26:04 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-----------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-----------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::St pipeline-sam-app User Initiated
ack
CREATE_IN_PROGRESS AWS::IAM::Role CodeBuildServiceRole -
CREATE_IN_PROGRESS AWS::CodeStarConnection CodeStarConnection -
s::Connection
CREATE_IN_PROGRESS AWS::IAM::Role PipelineStackCloudForma -
tionExecutionRole
CREATE_IN_PROGRESS AWS::CodeStarConnection CodeStarConnection Resource creation
s::Connection Initiated
CREATE_IN_PROGRESS AWS::IAM::Role PipelineStackCloudForma Resource creation
tionExecutionRole Initiated
CREATE_COMPLETE AWS::CodeStarConnection CodeStarConnection -
s::Connection
CREATE_IN_PROGRESS AWS::IAM::Role CodeBuildServiceRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role PipelineStackCloudForma -
tionExecutionRole
CREATE_COMPLETE AWS::IAM::Role CodeBuildServiceRole -
CREATE_IN_PROGRESS AWS::CodeBuild::Project CodeBuildProjectDeploy -
CREATE_IN_PROGRESS AWS::CodeBuild::Project CodeBuildProjectBuildAn -
dPackage
CREATE_IN_PROGRESS AWS::CodeBuild::Project CodeBuildProjectDeploy Resource creation
Initiated
CREATE_IN_PROGRESS AWS::CodeBuild::Project CodeBuildProjectBuildAn Resource creation
dPackage Initiated
CREATE_COMPLETE AWS::CodeBuild::Project CodeBuildProjectDeploy -
CREATE_COMPLETE AWS::CodeBuild::Project CodeBuildProjectBuildAn -
dPackage
CREATE_IN_PROGRESS AWS::IAM::Role CodePipelineExecutionRo -
le
CREATE_IN_PROGRESS AWS::IAM::Role CodePipelineExecutionRo Resource creation
le Initiated
CREATE_COMPLETE AWS::IAM::Role CodePipelineExecutionRo -
le
CREATE_IN_PROGRESS AWS::CodePipeline::Pipe Pipeline -
line
CREATE_IN_PROGRESS AWS::CodePipeline::Pipe Pipeline Resource creation
line Initiated
CREATE_COMPLETE AWS::CodePipeline::Pipe Pipeline -
line
CREATE_COMPLETE AWS::CloudFormation::St pipeline-sam-app -
ack
-----------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------------
Key CodeStarConnectionArn
Description The Arn of AWS CodeStar Connection used to connect to external code repositories.
Value arn:aws:codestar-connections:eu-
west-1:00000000000:connection/0b2a540b-8af9-490f-91e7-24e26e16a313
-------------------------------------------------------------------------------------------------------
Successfully created/updated stack - pipeline-sam-app in eu-west-1
Se ha creado un nuevo stack para desplegar nuestro AWS CodePipeline:
Ahora, necesitamos acceder a AWS CodePipeline para verificar la ejecución.
Sin embargo, la primera ejecución ha fallado como podemos ver en la siguiente imagen:
Podemos ver en el flujo de CodePipeline que se han creado todos los pasos:
- Source: integrado con GitHub como indicamos antes
- UpdatePipeline: el pipeline puede actualizarse a sí mismo
- BuildAndPackage: la aplicación SAM se construye, empaqueta y sube (con el servicio AWS CodeBuild)
- DeployTest: la aplicación SAM se despliega (con el servicio AWS CodeBuild)
La causa del error fue que la conexión entre GitHub y AWS debe confirmarse después de ser creada:
Paso 5: Conectar el repositorio Git con el sistema CI/CD
Si estás usando GitHub o Bitbucket, después de ejecutar el comando
sam deploypara tu pipeline, necesitas completar la conexión pendiente en la sección Settings/Connection de las herramientas de desarrollo.Además, podrías guardar una copia del CodeStarConnectionArn de la salida del comando sam deploy, porque lo necesitarás si quieres usar AWS CodePipeline con otra rama diferente a main.
Al acceder a Settings/Connections en las herramientas de desarrollo, puedes validar que la conexión está pendiente de aprobación:
Después de activarla, ejecutamos el pipeline nuevamente (haciendo clic en el botón Release change) y ahora el pipeline termina correctamente.
2. Actualizar los pasos CI/CD en el proyecto SAM
Ten en cuenta que ahora tenemos un pipeline que primero verifica cambios en el pipeline mismo y luego verifica el código y despliega los recursos.
Paso 1: Actualizar los pasos en el pipeline automáticamente
Con esta configuración de pipeline (con el paso
UpdatePipeline) todos los cambios que hagamos en el pipeline se actualizarán automáticamente.
Queremos probar la actualización automática del pipeline si hacemos algunos cambios.
Entonces, cambiemos los pasos del pipeline para:
- eliminar el paso
UpdatePipeline - añadir el paso
UnitTest
Para hacer esto, tenemos que actualizar el archivo codepipeline.yaml con los cambios necesarios:
- comentar todo el código del paso
UpdatePipeline - descomentar todo el código del paso
UnitTest
Y después de eso, hacer commit de los cambios y pushearlos al repositorio:
Cuando pusheamos los cambios, el paso UpdatePipeline ejecuta una actualización en el stack pipeline-sam-app (en el servicio CloudFormation) y actualizará la definición del pipeline.
Como esperábamos, el pipeline se ha actualizado a sí mismo y ahora tenemos el paso UnitTest pero no UpdatePipeline.
Paso 2: Actualizar los pasos en el pipeline manualmente
Si eliminas el paso
UpdatePipeline, cuando pushees un cambio al repositorio el pipeline no se actualizará, así que tienes que ejecutar manualmente la actualización del pipeline.
Para actualizar el pipeline tenemos que ejecutar nuevamente el comando sam deploy -t codepipeline.yaml --stack-name pipeline-sam-app --capabilities=CAPABILITY_IAM.
Ahora, eliminaremos la etapa UnitTest.
1
sam deploy -t codepipeline.yaml --stack-name pipeline-sam-app --capabilities=CAPABILITY_IAM
Haz clic para ver la salida del comando
Deploying with following values
===============================
Stack name : pipeline-sam-app
Region : eu-west-1
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : None
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Waiting for changeset to be created..
CloudFormation stack changeset
-----------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-----------------------------------------------------------------------------------------------------
* Modify CodeBuildProjectBuildAn AWS::CodeBuild::Project Conditional
dPackage
* Modify CodeBuildProjectDeploy AWS::CodeBuild::Project Conditional
* Modify CodeBuildServiceRole AWS::IAM::Role False
* Modify CodePipelineExecutionRo AWS::IAM::Role False
le
* Modify CodeStarConnection AWS::CodeStarConnection False
s::Connection
* Modify PipelineStackCloudForma AWS::IAM::Role False
tionExecutionRole
* Modify Pipeline AWS::CodePipeline::Pipe False
line
- Delete CodeBuildProjectUnitTes AWS::CodeBuild::Project N/A
t
-----------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:eu-west-1:00000000000:changeSet/samcli-deploy1706140589/27c840fe-922c-4232-861f-51c03d45471c
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: > y
2024-01-25 00:57:26 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-----------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-----------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS AWS::CloudFormation::St pipeline-sam-app User Initiated
ack
UPDATE_COMPLETE AWS::IAM::Role PipelineStackCloudForma -
tionExecutionRole
UPDATE_COMPLETE AWS::IAM::Role CodeBuildServiceRole -
UPDATE_COMPLETE AWS::CodeStarConnection CodeStarConnection -
s::Connection
UPDATE_COMPLETE AWS::CodeBuild::Project CodeBuildProjectBuildAn -
dPackage
UPDATE_COMPLETE AWS::CodeBuild::Project CodeBuildProjectDeploy -
UPDATE_IN_PROGRESS AWS::IAM::Role CodePipelineExecutionRo -
le
UPDATE_COMPLETE AWS::IAM::Role CodePipelineExecutionRo -
le
UPDATE_IN_PROGRESS AWS::CodePipeline::Pipe Pipeline -
line
UPDATE_COMPLETE AWS::CodePipeline::Pipe Pipeline -
line
UPDATE_COMPLETE_CLEANUP AWS::CloudFormation::St pipeline-sam-app -
_IN_PROGRESS ack
DELETE_IN_PROGRESS AWS::CodeBuild::Project CodeBuildProjectUnitTes -
t
DELETE_COMPLETE AWS::CodeBuild::Project CodeBuildProjectUnitTes -
t
UPDATE_COMPLETE AWS::CloudFormation::St pipeline-sam-app -
ack
-----------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------------
Key CodeStarConnectionArn
Description The Arn of AWS CodeStar Connection used to connect to external code repositories.
Value arn:aws:codestar-connections:eu-
west-1:00000000000:connection/0b2a540b-8af9-490f-91e7-24e26e16a313
-------------------------------------------------------------------------------------------------------
Successfully created/updated stack - pipeline-sam-app in eu-west-1
Y el pipeline se actualizará:
Después de todos los cambios que hicimos:
- Ahora, tenemos 3 pasos en nuestro CodePipeline:
- Source: integrado con GitHub como indicamos antes
- BuildAndPackage: la aplicación SAM se construye, empaqueta y sube (con el servicio AWS CodeBuild)
- DeployTest: la aplicación SAM se despliega (con el servicio AWS CodeBuild)
- Para resumir el estado actual:
- Si cambiamos la aplicación SAM y actualizamos el código en nuestro repositorio GitHub, el pipeline actualizará los recursos en nuestra cuenta AWS.
- Si queremos actualizar el pipeline mismo, tenemos que actualizar los archivos específicos del pipeline en nuestra aplicación SAM, y luego ejecutar manualmente el comando
sam deploy -t codepipeline.yaml --stack-name pipeline-sam-app --capabilities=CAPABILITY_IAM.
3. Limpieza
Hemos creado 3 o 4 stacks en CloudFormation relacionados con SAM, dependiendo de si ya habías usado AWS SAM antes (entonces el aws-sam-cli-managed-default ya existía):
- aws-sam-cli-managed-default: recursos generales de SAM
- sam-app: código de la aplicación
- pipeline-sam-app: CI/CD del sam-app
- aws-sam-cli-managed-test-pipeline-resources: recursos de la etapa test
Si quieres usar AWS SAM en el futuro podrías mantener el stack
aws-sam-cli-managed-default.
Tienes varias formas de eliminar tus recursos:
- Servicio AWS CloudFormation
- AWS CLI
- AWS SAM CLI
Si ejecutas el comando
sam delete, solo eliminará el stack principal (sam-app) pero no el pipeline CI/CD o el stack de recursos de etapa, así que tienes que especificar el stack del pipeline en la segunda ejecución.
1
sam delete --stack-name pipeline-sam-app
Y no olvides eliminar el stack de recursos del entorno:
1
sam delete --stack-name aws-sam-cli-managed-test-pipeline-resources
Resumen
Eso nos lleva al final de nuestro viaje de integración de CI/CD en proyectos AWS SAM. Recapitulemos los puntos destacados:
- Facilidad de despliegue con SAM CLI: Utilizamos el comando
sam pipelinepara un proceso de despliegue simplificado. Es eficiente y simplifica el despliegue de aplicaciones SAM. - Personalización del Pipeline: Demostrando la adaptabilidad de AWS SAM, usamos con éxito una plantilla personalizada para un pipeline de una sola etapa, permitiendo estrategias de despliegue personalizadas.
- Automatización del despliegue: Destacando el poder de las herramientas de AWS, hemos automatizado nuestros despliegues, lo que simplifica la gestión de aplicaciones y asegura que nuestras apps estén siempre actualizadas.
Próximos pasos
Lectura adicional:
- SAM + CDK: ¿Interesado en cómo AWS SAM y AWS CDK pueden trabajar juntos? He explorado esto en otro artículo: Cómo crear aplicaciones serverless con CDK y SAM. Es un gran siguiente paso para aquellos que buscan expandir su conocimiento de arquitectura serverless.
- CDK: Cómo crear aplicaciones Serverless con CDK
- Terraform: Cómo crear aplicaciones Serverless con Terraform
Gracias por leer, y espero que este artículo haya sido informativo y útil para configurar tu pipeline CI/CD. Espero escuchar tus pensamientos y experiencias con AWS SAM. Siéntete libre de compartirlos en los comentarios a continuación. ¡Feliz codificación!