Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Uso CI/CD de sistemas y canalizaciones para implementar con AWS SAM AWS SAM ayuda a las organizaciones a crear canalizaciones para sus CI/CD sistemas preferidos, de modo que puedan aprovechar los beneficios de ellos CI/CD con un mínimo esfuerzo, como acelerar la frecuencia de implementación, acortar el tiempo de espera de los cambios y reducir los errores de implementación. AWS SAM simplifica CI/CD las tareas de las aplicaciones sin servidor con la ayuda de la creación de imágenes de contenedores. Las imágenes que se AWS SAM proporcionan incluyen las herramientas de compilación AWS SAMCLI y las herramientas para varios tiempos de ejecución compatibles AWS Lambda . Esto facilita la creación y el empaquetado de aplicaciones sin servidor mediante el. AWS SAMCLI Estas imágenes también reducen la necesidad de que los equipos creen y administren sus propias imágenes para CI/CD los sistemas. Para obtener más información sobre la AWS SAM creación de imágenes de contenedores, consulte[Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). Varios CI/CD sistemas admiten la AWS SAM creación de imágenes de contenedores. CI/CD El sistema que debe utilizar depende de varios factores. Estos incluyen si la aplicación utiliza uno o varios tiempos de ejecución, o si desea compilar la aplicación dentro de una imagen del contenedor o directamente en una máquina host, ya sea una máquina virtual (VM) o un host bare metal. AWS SAM también proporciona un conjunto de plantillas de canalización predeterminadas para varios CI/CD sistemas que resumen las mejores prácticas AWS de implementación. Estas plantillas de canalización predeterminadas utilizan formatos de configuración de JSON/YAML canalización estándar, y las prácticas recomendadas integradas ayudan a realizar despliegues con múltiples cuentas y múltiples regiones, y a verificar que las canalizaciones no puedan realizar cambios involuntarios en la infraestructura. Tiene dos opciones principales AWS SAM para implementar sus aplicaciones sin servidor: 1) Modificar la configuración de canalización existente para usar AWS SAMCLI comandos, o 2) generar un ejemplo de configuración de CI/CD canalización que pueda usar como punto de partida para su propia aplicación. **Topics** + [¿Qué es una canalización?](#deploying-whatis-pipeline) + [Cómo se AWS SAM cargan los archivos locales en el momento de la implementación](deploy-upload-local-files.md) + [Genera una CI/CD canalización inicial con AWS SAM](serverless-generating-example-ci-cd.md) + [Cómo personalizar las canalizaciones iniciales con AWS SAM](serverless-customizing-starter-pipelines.md) + [Automatice la implementación de su AWS SAM aplicación](serverless-deploying-modify-pipeline.md) + [Cómo utilizar la autenticación OIDC con canalizaciones AWS SAM](deploying-with-oidc.md) ## ¿Qué es una canalización? Una canalización es una secuencia automática de pasos que se llevan a cabo para lanzar una nueva versión de una aplicación. [Con AWS SAMél, puede usar muchos CI/CD sistemas comunes para implementar sus aplicaciones, incluidos [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) y Actions. GitHub](https://github.com/features/actions) Las plantillas de Pipeline incluyen las mejores prácticas de AWS implementación para facilitar las implementaciones con múltiples cuentas y múltiples regiones. AWS Los entornos como los de desarrollo y producción suelen existir en cuentas diferentes. AWS Esto permite a los equipos de desarrollo configurar canalizaciones de implementación seguras, sin realizar cambios involuntarios en la infraestructura. También puede proporcionar sus propias plantillas de canalización personalizadas para ayudar a estandarizar las canalizaciones en todos los equipos de desarrollo. # Cómo se AWS SAM cargan los archivos locales en el momento de la implementación Cuando despliega su aplicación en Nube de AWS, AWS CloudFormation requiere que sus archivos locales se carguen primero en un AWS servicio accesible, como Amazon Simple Storage Service (Amazon S3). Esto incluye los archivos locales a los que hace referencia tu AWS SAM plantilla. Para cumplir con este requisito, la CLI de AWS SAM hace lo siguiente cuando utiliza el comando `sam deploy` o `sam package`: 1. Carga automáticamente sus archivos locales a un AWS servicio accesible. 1. Actualiza automáticamente la plantilla de la aplicación para hacer referencia a la nueva ruta del archivo. **Topics** + [Demostración: utiliza la CLI de AWS SAM para cargar el código de la función de Lambda](#deploy-upload-local-files-demo) + [Casos de uso admitidos](#deploy-upload-local-files-use) + [Más información](#deploy-upload-local-files-learn) ## Demostración: utiliza la CLI de AWS SAM para cargar el código de la función de Lambda En esta demostración, inicializamos la aplicación Hello World de ejemplo con un tipo de paquete .zip para la función de Lambda. Utilizamos la CLI de AWS SAM para cargar automáticamente el código de la función de Lambda en Amazon S3 y hacer referencia a su nueva ruta en la plantilla de aplicación. Primero, ejecutamos `sam init` para inicializar la aplicación Hello World. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: y Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: demo ----------------------- Generating application: ----------------------- Name: demo Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: demo/samconfig.toml ... ``` El código de la función de Lambda está organizado en el subdirectorio `hello_world` de nuestro proyecto. ``` demo ├── README.md ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── template.yaml └── tests ``` En nuestra AWS SAM plantilla, hacemos referencia a la ruta local al código de nuestra función Lambda mediante la `CodeUri` propiedad. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.9 ... ``` A continuación, ejecuta `sam build` para crear e implementar la aplicación. ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../demo/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml ... ``` A continuación, ejecuta `sam deploy --guided` para crear e implementar la aplicación. ``` $ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [demo]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: n #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Saved arguments to config file Running 'sam deploy' for future deployments will use the parameters saved above. The above parameters can be changed by modifying samconfig.toml Learn more about samconfig.toml syntax at https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : demo Region : us-west-2 Confirm changeset : False Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== ... Waiting for changeset to be created.. CloudFormation stack changeset ------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement ------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A oWorldPermissionProd n + Add HelloWorldFunctionRole AWS::IAM::Role N/A ... ------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f 2023-04-07 12:24:58 - 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::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated ... ------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ------------------------------------------------------------------------------------------------- Outputs ------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:demo- HelloWorldFunction-G14inKTmSQvK ------------------------------------------------------------------------------------------------- Successfully created/updated stack - demo in us-west-2 ``` Durante la implementación, la CLI de AWS SAM carga automáticamente el código de la función de Lambda a Amazon S3 y actualiza la plantilla. Nuestra plantilla modificada en la CloudFormation consola refleja la ruta del bucket de Amazon S3. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8 Handler: app.lambda_handler ... ``` ## Casos de uso admitidos AWS SAMCLIPuede facilitar automáticamente este proceso para varios tipos de archivos, tipos de CloudFormation recursos y CloudFormation macros. ### Tipos de archivos Se admiten archivos de aplicaciones e imágenes de Docker. ### CloudFormation tipos de recursos La siguiente es una lista de los tipos de recursos compatibles y sus propiedades: | Recurso | Propiedades | | --- | --- | | AWS::ApiGateway::RestApi | BodyS3Location | | AWS::ApiGatewayV2::Api | BodyS3Location | | AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::AppSync::GraphQLSchema | DefinitionS3Location | | AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::CloudFormation::ModuleVersion | ModulePackage | | AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage | | AWS::ECR::Repository | RepositoryName | | AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle | | AWS::Glue::Job | Command.ScriptLocation | | AWS::Lambda::Function | `Code` `Code.ImageUri` | | AWS::Lambda::LayerVersion | Content | | AWS::Serverless::Api | DefinitionUri | | AWS::Serverless::Function | `CodeUri` `ImageUri` | | AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` | | AWS::Serverless::HttpApi | DefinitionUri | | AWS::Serverless::LayerVersion | ContentUri | | AWS::Serverless::StateMachine | DefinitionUri | | AWS::StepFunctions::StateMachine | DefinitionS3Location | ### CloudFormation macros Se admiten los archivos a los que se hace referencia mediante la macro de transformación de `AWS::Include`. ## Más información Para obtener más información sobre la `AWS::Include` transformación, consulte la [ AWS::Include transformación](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) en la *Guía del AWS CloudFormation usuario*. Para ver un ejemplo del uso de la `AWS::Include` transformación en una AWS SAM plantilla, consulta el patrón [API HTTP a SQS de API Gateway](https://serverlessland.com/patterns/apigw-sqs) en *Serverless Land*. # Genera una CI/CD canalización inicial con AWS SAM Cuando esté listo para automatizar la implementación, puede usar una de las plantillas AWS SAM de canalización iniciales para generar una canalización de implementación para el CI/CD sistema que elija usar. La canalización de implementación es lo que configura y usa para automatizar la implementación de su aplicación sin servidor. Hay una plantilla de canalización de inicio preconfigurada para ayudarle a configurar rápidamente la canalización de implementación de la aplicación sin servidor. Con una plantilla de canalización de inicio, puede generar canalizaciones en cuestión de minutos con el comando [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md). Las plantillas de canalización iniciales utilizan la JSON/YAML sintaxis habitual del CI/CD sistema e incorporan las mejores prácticas, como la gestión de los artefactos en varias cuentas y regiones y el uso de la cantidad mínima de permisos necesarios para implementar la aplicación. [Actualmente, la AWS SAM CLI admite la generación de configuraciones de CI/CD canalización iniciales para [AWS CodePipeline](https://aws.amazon.com/codepipeline)las canalizaciones de [Jenkins](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), [GitHub Actions](https://github.com/features/actions) y Bitbucket.](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) Estas son las tareas de alto nivel que debes realizar para generar una configuración de canalización inicial: 1. **Cree recursos de infraestructura**: su canalización requiere ciertos AWS recursos, por ejemplo, el usuario y las funciones de IAM con los permisos necesarios, un bucket de Amazon S3 y, opcionalmente, un repositorio de Amazon ECR. 1. **Conecta tu repositorio de Git con tu CI/CD sistema**: tu CI/CD sistema necesita saber qué repositorio de Git activará la canalización para que se ejecute. Ten en cuenta que este paso puede no ser necesario, dependiendo de la combinación de repositorio y CI/CD sistema de Git que utilices. 1. **Genera tu configuración de canalización**: este paso genera una configuración de canalización inicial que incluye dos etapas de implementación. 1. **Confirma la configuración de la canalización en tu repositorio de Git**: este paso es necesario para garantizar que el CI/CD sistema conozca la configuración de la canalización y se ejecute cuando se confirmen los cambios. Una vez que hayas generado la configuración de canalización inicial y la hayas asignado a tu repositorio de Git, cada vez que alguien realice un cambio de código en ese repositorio, tu canalización se activará para que se ejecuta automáticamente. El orden de estos pasos y los detalles de cada uno de ellos varían en función del sistema de CI/CD: + Si está utilizando AWS CodePipeline, consulte[Generando una tubería de arranque para AWS CodePipeline en AWS SAM](serverless-generating-example-ci-cd-codepipeline.md). + Si utiliza Jenkins, GitLab CI/CD, GitHub Actions o Bitbucket Pipelines, consulte. [Se usa AWS SAM para generar canalizaciones iniciales para Jenkins, GitLab CI/CD, Actions y Bitbucket Pipelines GitHub](serverless-generating-example-ci-cd-others.md) # Generando una tubería de arranque para AWS CodePipeline en AWS SAM Para generar una configuración de canalización inicial para AWS CodePipeline, realice las siguientes tareas en este orden: 1. Crea recursos de infraestructura 1. Genere la configuración de la canalización 1. Confirme la configuración de su canalización en Git 1. Conecta tu repositorio de Git con tu CI/CD sistema **nota** El siguiente procedimiento utilizas dos comandos CLI de AWS SAM, `sam pipeline bootstrap` y `sam pipeline init`. La razón por la que hay dos comandos es para gestionar el caso de uso en el que los administradores (es decir, los usuarios que necesitan permiso para configurar los AWS recursos de infraestructura, como los usuarios y las funciones de IAM) tienen más permisos que los desarrolladores (es decir, los usuarios que solo necesitan permiso para configurar canalizaciones individuales, pero no los AWS recursos de infraestructura necesarios). ## Paso 1: cree recursos de infraestructura Las canalizaciones que se utilizan AWS SAM requieren determinados AWS recursos, como un usuario de IAM y las funciones con los permisos necesarios, un bucket de Amazon S3 y, opcionalmente, un repositorio de Amazon ECR. Debe tener un conjunto de recursos de infraestructura para cada etapa de implementación de la canalización. Puedes ejecutar el siguiente comando para editar o agregar esta configuración: ``` sam pipeline bootstrap ``` **nota** Ejecuta el comando anterior para cada etapa de implementación de su canalización. ## Paso 2: genere la configuración de la canalización Para generar la configuración de la canalización, ejecuta el siguiente comando: ``` sam pipeline init ``` ## Paso 3: confirme la configuración de su canalización en el repositorio de Git Este paso es necesario para garantizar que el CI/CD sistema conozca la configuración de la canalización y se ejecute cuando se realicen los cambios. ## Paso 4: Conecta tu repositorio de Git con tu CI/CD sistema Pues ahora AWS CodePipeline puedes crear la conexión ejecutando el siguiente comando: ``` sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region ``` Si utilizas GitHub Bitbucket, después de ejecutar el **sam deploy** comando anteriormente, completa la conexión siguiendo los pasos descritos en **Para completar una conexión, que se encuentran en el tema Actualizar una conexión** [pendiente](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) de la *guía del usuario de la consola de Developer Tools*. Además, guarda una copia del resultado `CodeStarConnectionArn` del **sam deploy** comando, ya que la necesitarás si quieres usarla AWS CodePipeline con otra rama que no sea`main`. ## Configuración de otras ramificaciones De forma predeterminada, AWS CodePipeline usa la `main` rama con AWS SAM. Si quieres utilizar una ramificación que no sea `main`, debes volver a ejecutar el comando **sam deploy**. Ten en cuenta que, en función del repositorio de Git que utilices, es posible que también tengas que proporcionar el `CodeStarConnectionArn`: ``` # For GitHub and Bitbucket sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn=" # For AWS CodeCommit sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch=" ``` ## Más información Para ver un ejemplo práctico de cómo configurar una CI/CD canalización, consulta [CI/CD AWS CodePipeline en *The* Complete](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) Workshop. AWS SAM # Se usa AWS SAM para generar canalizaciones iniciales para Jenkins, GitLab CI/CD, Actions y Bitbucket Pipelines GitHub Para generar una configuración de canalización inicial para Jenkins, GitLab CI/CD, GitHub Actions o Bitbucket Pipelines, realiza las siguientes tareas en este orden: 1. Crea recursos de infraestructura 1. Conecta tu repositorio de Git con tu CI/CD sistema 1. Crea objetos de credenciales 1. Genera la configuración de la canalización 1. Confirma su configuración de la canalización en el repositorio de Git **nota** El siguiente procedimiento utilizas dos comandos CLI de AWS SAM, `sam pipeline bootstrap` y `sam pipeline init`. La razón por la que hay dos comandos es para gestionar el caso de uso en el que los administradores (es decir, los usuarios que necesitan permiso para configurar los AWS recursos de infraestructura, como los usuarios y las funciones de IAM) tienen más permisos que los desarrolladores (es decir, los usuarios que solo necesitan permiso para configurar canalizaciones individuales, pero no los AWS recursos de infraestructura necesarios). ## Paso 1: cree recursos de infraestructura Las canalizaciones que se utilizan AWS SAM requieren determinados AWS recursos, como un usuario de IAM y las funciones con los permisos necesarios, un bucket de Amazon S3 y, opcionalmente, un repositorio de Amazon ECR. Debe tener un conjunto de recursos de infraestructura para cada etapa de implementación de la canalización. Puedes ejecutar el siguiente comando para editar o agregar esta configuración: ``` sam pipeline bootstrap ``` **nota** Ejecuta el comando anterior para cada etapa de implementación de su canalización. Debe capturar AWS las credenciales (el identificador de clave y la clave secreta) de los usuarios de la canalización para cada etapa de despliegue de la canalización, ya que son necesarias para los pasos siguientes. ## Paso 2: Conecta tu repositorio de Git con tu CI/CD sistema Es necesario conectar el repositorio de Git al CI/CD sistema para que el CI/CD sistema pueda acceder al código fuente de la aplicación para compilaciones e implementaciones. **nota** Puedes omitir este paso si utilizas una de las siguientes combinaciones, ya que la conexión se realiza automáticamente: GitHub Acciones con el repositorio GitHub GitLab CI/CD con repositorio GitLab Bitbucket Pipelines con repositorio de Bitbucket Para conectar el repositorio de Git con el CI/CD sistema, realiza una de las siguientes acciones: + Si utilizas Jenkins, consulta la [documentación de Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/) para «añadir un origen de ramificación». + Si utilizas GitLab CI/CD y otro repositorio de Git GitLab, consulta la [GitLabdocumentación](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) para «conectar un repositorio externo». ## Paso 3: crear objetos de credenciales Cada CI/CD sistema tiene su propia forma de administrar las credenciales necesarias para que el CI/CD sistema acceda a tu repositorio de Git. Para crear los objetos de credenciales necesarios, haz una de las siguientes acciones: + Si utilizas Jenkins, cree una «credencial» única que almacene tanto el identificador como la contraseña. Sigue las instrucciones del blog [Cómo crear una canalización con Jenkins con AWS SAM](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), en la sección **Configurar Jenkins**. Necesitarás el «identificador de credencial» para el siguiente paso. + Si utilizas GitLab CI/CD, crea dos «variables protegidas», una para cada identificador de clave y clave secreta. Siga las instrucciones de la [GitLab documentación](https://docs.gitlab.com/ee/ci/variables/): necesitará dos «claves variables» para el siguiente paso. + Si utilizas GitHub Actions, crea dos «secretos cifrados», uno para cada clave y una clave secreta. Sigue las instrucciones de la [GitHubdocumentación](https://docs.github.com/en/actions/reference/encrypted-secrets): necesitarás dos «nombres secretos» para el siguiente paso. + Si utilizas Bitbucket Pipelines, crea dos «variables seguras», una para cada identificador y contraseña. Sigue las instrucciones de las [variables y secretos](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets); necesitarás dos «nombres secretos» para el siguiente paso. ## Paso 4: genere la configuración de la canalización Para generar la configuración de la canalización, ejecuta el siguiente comando. Necesitará introducir el objeto de credenciales que creaste en el paso anterior: ``` sam pipeline init ``` ## Paso 5: confirma la configuración de su canalización en el repositorio de Git Este paso es necesario para garantizar que el CI/CD sistema conozca la configuración de la canalización y se ejecute cuando se realicen los cambios. ## Más información Para ver un ejemplo práctico de cómo configurar una CI/CD canalización mediante el uso de este GitHub Actions método, consulte [CI/CD GitHub en *The* Complete](https://s12d.com/sam-ws-en-gh) Workshop. AWS SAM # Cómo personalizar las canalizaciones iniciales con AWS SAM Como CI/CD administrador, es posible que desee personalizar una plantilla de canalización inicial y las instrucciones guiadas asociadas, para que los desarrolladores de su organización puedan usar para crear configuraciones de canalización. La CLI de AWS SAM utiliza plantillas de Cookiecutter para crear plantillas de inicio. Para obtener más información sobre las plantillas de cookie cutter, [Cookiecutter.](https://cookiecutter.readthedocs.io/en/latest/README.html) También puedes personalizar las instrucciones que la CLI de AWS SAM muestra a los usuarios al crear configuraciones de canalización mediante el comando `sam pipeline init`. Para personalizar las solicitudes de usuario, haga lo siguiente: 1. **Crea un archivo de `questions.json`**: el archivo `questions.json` debes estar en la raíz del repositorio del proyecto. Este es el mismo directorio que el del archivo `cookiecutter.json`. Para ver el esquema del archivo `questions.json`, consulta [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). Para ver un ejemplo de archivo `questions.json`, consulta [questions.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json). 1. **Asigna las claves de preguntas a los nombres de los cookiecutter**: cada objeto del archivo `questions.json` necesita una claves que coincida con el nombre de la plantilla del cookiecutter. Esta coincidencia de claves es la forma en que la CLI de AWS SAM asigna las respuestas de las preguntas del usuario a la plantilla cookie cutter. Para obtener ejemplos de esta coincidencia de claves, consulta la sección [Archivos de ejemplo](#serverless-customizing-starter-pipelines-example-files) más adelante en este tema. 1. **Crea un archivo `metadata.json`**: declara el número de etapas que tendrá la canalización en el archivo de `metadata.json`. El número de etapas indica al comando `sam pipeline init` sobre cuántas etapas debes solicitar información o, en el caso de la opción `--bootstrap`, para cuántas etapas debes crear los recursos de infraestructura. Para ver un ejemplo de archivo `metadata.json` que declara una canalización con dos etapas, consulta [metadata.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json). ## Proyectos de ejemplo Estos son ejemplos de proyectos, cada uno de los cuales incluye una plantilla de Cookiecutter, un archivo `questions.json` y un archivo `metadata.json`: + Ejemplo de Jenkins: [plantilla de canalización de Jenkins en dos etapas](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template) + CodePipeline Ejemplo: plantilla de [ CodePipeline canalización en dos etapas](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template) ## Archivos de ejemplo El siguiente conjunto de archivos muestra cómo se asocian las preguntas del archivo `questions.json` a las entradas del archivo de plantilla de Cookiecutter. Tenga en cuenta que estos ejemplos son fragmentos de archivos, no archivos completos. Para ver ejemplos de archivos completos, consulta primero la sección [Proyectos de ejemplo](#serverless-customizing-starter-pipelines-example-projects) de este tema. Ejemplo: **`questions.json`** ``` { "questions": [{ "key": "intro", "question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n", "kind": "info" }, { "key": "pipeline_user_jenkins_credential_id", "question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?", "isRequired": true }, { "key": "sam_template", "question": "What is the template file path?", "default": "template.yaml" }, { ... ``` Ejemplo: **`cookiecutter.json`** ``` { "outputDir": "aws-sam-pipeline", "pipeline_user_jenkins_credential_id": "", "sam_template": "", ... ``` Ejemplo: **`Jenkinsfile`** ``` pipeline { agent any environment { PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}' SAM_TEMPLATE = '{{cookiecutter.sam_template}}' ... ``` # Automatice la implementación de su AWS SAM aplicación En AWS SAM, la forma de automatizar la implementación de su AWS SAM aplicación varía según el CI/CD sistema que utilice. Por este motivo, los ejemplos de esta sección muestran cómo configurar varios CI/CD sistemas para automatizar la creación de aplicaciones sin servidor en una imagen de contenedor de AWS SAM compilación. Estas imágenes de contenedores de compilación facilitan la creación y el empaquetado de aplicaciones sin servidor mediante el. AWS SAMCLI Los procedimientos que utiliza su CI/CD canal actual para implementar aplicaciones sin servidor AWS SAM son ligeramente diferentes según el CI/CD sistema que utilice. En los temas siguientes se proporcionan ejemplos para configurar el CI/CD sistema para crear aplicaciones sin servidor dentro de una imagen de contenedor de AWS SAM compilación: **Topics** + [Uso AWS CodePipeline para implementar con AWS SAM](deploying-using-codepipeline.md) + [Uso de Bitbucket Pipelines para realizar despliegues con AWS SAM](deploying-using-bitbucket.md) + [Uso de Jenkins para implementar con AWS SAM](deploying-using-jenkins.md) + [Uso de GitLab CI/CD para implementar con AWS SAM](deploying-using-gitlab.md) + [Uso de GitHub acciones para implementar con AWS SAM](deploying-using-github.md) # Uso AWS CodePipeline para implementar con AWS SAM Para configurar la [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)canalización de forma que se automatice la creación y el despliegue de AWS SAM la aplicación, la CloudFormation plantilla y el `buildspec.yml` archivo deben contener líneas que hagan lo siguiente: 1. Hacer referencia a una imagen de contenedor de compilación con el tiempo de ejecución necesario a partir de las imágenes disponibles. En el siguiente ejemplo, se utiliza la imagen del contenedor de compilación `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure las etapas de canalización para ejecutar los AWS SAM comandos de la interfaz de línea de comandos (CLI) necesarios. El siguiente ejemplo ejecuta dos comandos CLI de AWS SAM: **sam build** y **sam deploy** (con las opciones necesarias). En este ejemplo se supone que ha declarado todas las funciones y capas del archivo AWS SAM de plantilla con`runtime: nodejs20.x`. **CloudFormation fragmento de plantilla:** ``` CodeBuildProject: Type: AWS::CodeBuild::Project Properties: Environment: ComputeType: BUILD_GENERAL1_SMALL Image: public.ecr.aws/sam/build-nodejs20.x Type: LINUX_CONTAINER ... ``` **Fragmento de `buildspec.yml`:** ``` version: 0.2 phases: build: commands: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obtener una lista de imágenes de contenedor de compilación de Amazon Elastic Container Registry (Amazon ECR) disponibles para diferentes tiempos de ejecución, consulta [Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). # Uso de Bitbucket Pipelines para realizar despliegues con AWS SAM Para configurar [Bitbucket Pipeline](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) de forma que automatice la creación y el despliegue de AWS SAM la aplicación, el `bitbucket-pipelines.yml` archivo debe contener líneas que hagan lo siguiente: 1. Hacer referencia a una imagen de contenedor de compilación con el tiempo de ejecución necesario a partir de las imágenes disponibles. En el siguiente ejemplo, se utiliza la imagen del contenedor de compilación `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure las etapas de canalización para ejecutar los AWS SAM comandos de la interfaz de línea de comandos (CLI) necesarios. El siguiente ejemplo ejecuta dos comandos CLI de AWS SAM: **sam build** y **sam deploy** (con las opciones necesarias). En este ejemplo se supone que ha declarado todas las funciones y capas del archivo AWS SAM de plantilla con`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x pipelines: branches: main: # branch name - step: name: Build and Package script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obtener una lista de imágenes de contenedor de compilación de Amazon Elastic Container Registry (Amazon ECR) disponibles para diferentes tiempos de ejecución, consulta [Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). # Uso de Jenkins para implementar con AWS SAM Para configurar tu canalización de [Jenkins](https://www.jenkins.io/) para automatizar la creación y el despliegue de tu AWS SAM aplicación, `Jenkinsfile` debes incluir líneas que hagan lo siguiente: 1. Hacer referencia a una imagen de contenedor de compilación con el tiempo de ejecución necesario a partir de las imágenes disponibles. En el siguiente ejemplo, se utiliza la imagen del contenedor de compilación `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure las etapas de canalización para ejecutar los AWS SAM comandos de la interfaz de línea de comandos (CLI) necesarios. El siguiente ejemplo ejecuta dos comandos CLI de AWS SAM: **sam build** y **sam deploy** (con las opciones necesarias). En este ejemplo se supone que ha declarado todas las funciones y capas del archivo AWS SAM de plantilla con`runtime: nodejs20.x`. ``` pipeline { agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } } stages { stage('build') { steps { sh 'sam build' sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset' } } } } ``` Para obtener una lista de imágenes de contenedor de compilación de Amazon Elastic Container Registry (Amazon ECR) disponibles para diferentes tiempos de ejecución, consulta [Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). # Uso de GitLab CI/CD para implementar con AWS SAM Para configurar la [GitLab](https://about.gitlab.com)canalización de manera que se automatice la creación y el despliegue de AWS SAM la aplicación, el `gitlab-ci.yml` archivo debe contener líneas que hagan lo siguiente: 1. Hacer referencia a una imagen de contenedor de compilación con el tiempo de ejecución necesario a partir de las imágenes disponibles. En el siguiente ejemplo, se utiliza la imagen del contenedor de compilación `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure las etapas de canalización para ejecutar los AWS SAM comandos de la interfaz de línea de comandos (CLI) necesarios. El siguiente ejemplo ejecuta dos comandos CLI de AWS SAM: **sam build** y **sam deploy** (con las opciones necesarias). En este ejemplo se supone que ha declarado todas las funciones y capas del archivo AWS SAM de plantilla con`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x deploy: script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obtener una lista de imágenes de contenedor de compilación de Amazon Elastic Container Registry (Amazon ECR) disponibles para diferentes tiempos de ejecución, consulta [Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). # Uso de GitHub acciones para implementar con AWS SAM Para configurar la [GitHub](https://github.com/)canalización para automatizar la creación y el despliegue de la AWS SAM aplicación, primero debe instalar la interfaz de línea de AWS SAM comandos (CLI) en el host. Puedes usar [GitHub Actions](https://github.com/features/actions) en tu GitHub flujo de trabajo para ayudarte con esta configuración. El siguiente ejemplo de GitHub flujo de trabajo configura un host de Ubuntu mediante una serie de GitHub acciones y, a continuación, ejecuta AWS SAMCLI comandos para crear e implementar una AWS SAM aplicación: ``` on: push: branches: - main jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v3 - uses: aws-actions/setup-sam@v2 - uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-2 - run: sam build --use-container - run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obtener una lista de imágenes de contenedor de compilación de Amazon Elastic Container Registry (Amazon ECR) disponibles para diferentes tiempos de ejecución, consulta [Repositorios de imágenes para AWS SAM](serverless-image-repositories.md). # Cómo utilizar la autenticación OIDC con canalizaciones AWS SAM AWS Serverless Application Model (AWS SAM) admite la autenticación de usuarios de OpenID Connect (OIDC) para Bitbucket, GitHub Actions y la integración GitLab continua y la entrega continua (cuentas de CI/CD) platforms. With this support, you can use authorized CI/CD usuario) desde cualquiera de estas plataformas para gestionar tus canalizaciones de aplicaciones sin servidor. De lo contrario, tendrías que crear y gestionar varios usuarios AWS Identity and Access Management (IAM) para controlar el acceso a las canalizaciones. AWS SAM ## Configure OIDC con Pipeline AWS SAM Durante el proceso `sam pipeline bootstrap` de configuración, haz lo siguiente para configurar el OIDC con tu canalización. AWS SAM 1. Cuando se te pida que elijas un proveedor de identidad, selecciona **OIDC**. 1. A continuación, selecciona un proveedor de OIDC compatible. 1. Introduce la URL del proveedor del OIDC, empezando por **https://**. **nota** AWS SAM hace referencia a esta URL cuando genera el tipo de `AWS::IAM::OIDCProvider` recurso. 1. A continuación, siga las instrucciones e introduzca la información de la CI/CD plataforma necesaria para acceder a la plataforma seleccionada. Estos detalles varían según la plataforma y pueden incluir: + ID de cliente OIDC + Nombre del repositorio de código o identificador único universal (UUID) + Nombre del grupo o de la organización asociado con el repositorio + GitHub organización a la que pertenece el repositorio de código. + GitHub nombre del repositorio. + Ramificación desde la que se realizarán las implementaciones. 1. AWS SAM muestra un resumen de la configuración OIDC introducida. Introduce el número de una configuración para editarlo o pulsa Enter para continuar. 1. Cuando se te pida que confirmes la creación de los recursos necesarios para admitir la conexión OIDC introducida, pulsa Y para continuar. AWS SAM genera un `AWS::IAM::OIDCProvider` AWS CloudFormation recurso con la configuración proporcionada que asume la función de ejecución de la canalización. Para obtener más información sobre este tipo de CloudFormation recurso, consulte [AWS: :IAM:: OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) en la Guía del *AWS CloudFormation usuario*. **nota** Si el recurso del proveedor de identidad (IdP) ya existe en su cuenta Cuenta de AWS, AWS SAM haga referencia a él en lugar de crear uno nuevo. ## Ejemplo El siguiente es un ejemplo de cómo configurar el OIDC con Pipeline. AWS SAM ``` Select a permissions provider: 1 - IAM (default) 2 - OpenID Connect (OIDC) Choice (1, 2): 2 Select an OIDC provider: 1 - GitHub Actions 2 - GitLab 3 - Bitbucket Choice (1, 2, 3): 1 Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]: Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]: Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org Enter GitHub repository name: testing Enter the name of the branch that deployments will occur from [main]: [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: 123456 2 - Stage configuration name: dev 3 - Region: us-east-1 4 - OIDC identity provider URL: https://token.actions.githubusercontent.com 5 - OIDC client ID: sts.amazonaws.com 6 - GitHub organization: my-org 7 - GitHub repository: testing 8 - Deployment branch: main 9 - Pipeline execution role: [to be created] 10 - CloudFormation execution role: [to be created] 11 - Artifacts bucket: [to be created] 12 - 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 'dev' configuration: - IAM OIDC Identity Provider - Pipeline execution role - CloudFormation execution role - Artifact bucket Should we proceed with the creation? [y/N]: ``` ## Más información Para obtener más información sobre el uso de OIDC con AWS SAM Pipeline, consulte. [sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md)