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.
# Implemente su aplicación y sus recursos con AWS SAM
La implementación de su aplicación aprovisiona y configura sus AWS recursos en la AWS nube, lo que hace que su aplicación se ejecute en la nube. AWS SAM utiliza [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)como mecanismo de despliegue subyacente. AWS SAM utiliza los artefactos de compilación que se crean al ejecutar el **sam build** comando como entradas estándar para implementar la aplicación sin servidor.
Con AWS SAM ella, puede implementar su aplicación sin servidor manualmente o puede automatizar las implementaciones. Para automatizar las implementaciones, utilice AWS SAM canalizaciones con el sistema de integración e implementación continuas (CI/CD) de su elección. La canalización de implementación es una secuencia automatizada de pasos que se llevan a cabo para lanzar una nueva versión de la aplicación sin servidor.
En los temas de esta sección se proporcionan instrucciones sobre las implementaciones automatizadas y manuales. Para implementar la aplicación manualmente, utilizará comandos de la CLI de AWS SAM. Para automatizar las implementaciones, consulte los temas de esta sección. Proporcionan específicamente contenido detallado sobre la automatización de las implementaciones mediante canalizaciones y un sistema. CI/CD Esto incluye la generación de una canalización inicial, la configuración de la automatización, la solución de problemas de las implementaciones, el uso de la autenticación de usuarios de OpenID Connect (OIDC) y la carga de archivos locales en el momento de la implementación.
**Topics**
+ [Introducción a la implementación con AWS SAM](using-sam-cli-deploy.md)
+ [Opciones para implementar su aplicación con AWS SAM](deploying-options.md)
+ [Uso CI/CD de sistemas y canalizaciones para implementar con AWS SAM](deploying-cicd-overview.md)
+ [Introducción al uso sam sync de la sincronización con Nube de AWS](using-sam-cli-sync.md)
# Introducción a la implementación con AWS SAM
Utilice el AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam deploy` para implementar la Nube de AWS aplicación sin servidor en.
+ Para obtener una introducción al AWS SAMCLI, consulte[¿Qué es el? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli).
+ Para ver una lista de opciones de comandos `sam deploy`, consulta [sam deploy](sam-cli-command-reference-sam-deploy.md).
+ Para ver un ejemplo de uso de `sam deploy` durante un flujo de trabajo de desarrollo típico, consulta [Paso 3: Implemente la aplicación en Nube de AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy).
**Topics**
+ [Requisitos previos](#using-sam-cli-deploy-prerequisites)
+ [Implementación de aplicaciones mediante sam deploy](#using-sam-cli-deploy-deploying)
+ [Prácticas recomendadas](#using-sam-cli-deploy-best)
+ [Opciones para una implementación de sam](#using-sam-cli-deploy-options)
+ [Resolución de problemas](#using-sam-cli-deploy-troubleshooting)
+ [Ejemplos](#using-sam-cli-deploy-examples)
+ [Más información](#using-sam-cli-deploy-learn)
## Requisitos previos
Para usar `sam deploy`, completa lo siguiente para instalar la CLI de AWS SAM:
+ [AWS SAM requisitos previos](prerequisites.md).
+ [Instala la AWS SAM CLI](install-sam-cli.md).
Antes de usar `sam deploy`, se recomienda tener conocimientos básicos de lo siguiente:
+ [Configuración de la AWS SAM de CLI](using-sam-cli-configure.md).
+ [Crea tu aplicación en AWS SAM](using-sam-cli-init.md).
+ [Introducción a la construcción con AWS SAM](using-sam-cli-build.md).
## Implementación de aplicaciones mediante sam deploy
La primera vez que implementa una aplicación sin servidor, utiliza la opción `--guided`. La CLI de AWS SAM lo guiará a través de un flujo interactivo para configurar los ajustes de implementación de la aplicación.
**Para implementar una aplicación mediante el flujo interactivo**
1. Vaya al directorio raíz del proyecto. Esta es la misma ubicación que la AWS SAM plantilla.
```
$ cd sam-app
```
1. Use el siguiente comando:
```
$ sam deploy --guided
```
1. Durante el flujo interactivo, la CLI de AWS SAM le indica las opciones para configurar los ajustes de implementación de la aplicación.
Los corchetes (`[ ]`) indican los valores predeterminados. Deje la respuesta en blanco para seleccionar el valor predeterminado. Los valores predeterminados se obtienen de los siguientes archivos de configuración:
+ `~/.aws/config`— La configuración general AWS de tu cuenta.
+ `~/.aws/credentials`— Las credenciales AWS de su cuenta.
+ `/samconfig.toml`: el archivo de configuración de su proyecto.
Proporciona valores respondiendo a las instrucciones de la CLI de AWS SAM. Por ejemplo, puede introducir `y` para **sí**, `n` para **no** o cadenas de valores.
La CLI de AWS SAM escriba las respuestas en el archivo `samconfig.toml` del proyecto. Para implementaciones posteriores, puede utilizar la implementación `sam deploy` con estos valores configurados. Para volver a configurar estos valores, utiliza `sam deploy --guided` o modifique directamente los archivos de configuración.
El siguiente es un ejemplo de output:
```
sam-app $ 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 [sam-app]: 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]: ENTER
#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
```
1. A continuación, AWS SAMCLI despliega su aplicación en. Nube de AWS Durante la implementación, el progreso se muestra en el símbolo del sistema. Las etapas principales de la implementación son las siguientes:
+ En el caso de las aplicaciones con AWS Lambda funciones empaquetadas como un archivo.zip, comprime y carga el AWS SAMCLI paquete en un depósito de Amazon Simple Storage Service (Amazon S3). Si es necesario, la CLI de AWS SAM creará un nuevo bucket.
+ En el caso de las aplicaciones con las funciones de Lambda empaquetadas como imagen de contenedor, la CLI de AWS SAM carga la imagen en Amazon Elastic Container Registry (Amazon ECR). Si es necesario, la CLI de AWS SAM creará un repositorio nuevo.
+ AWS SAMCLICrea un conjunto de AWS CloudFormation cambios y despliega la aplicación como una pila. CloudFormation
+ AWS SAMCLIModifica la AWS SAM plantilla implementada con el nuevo `CodeUri` valor para las funciones de Lambda.
A continuación, se muestra un ejemplo de la salida de implementación de la CLI de AWS SAM:
```
Looking for resources needed for deployment:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
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
Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 262144 / 619839 (42.29%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 524288 / 619839 (84.58%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 619839 / 619839 (100.00%)
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
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
=====================
Uploading to sam-app-zip/be84c20f868068e4dc4a2c11966edf2d.template 1212 / 1212 (100.00%)
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
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-03 12:00:50 - 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
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app-zip -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-zip-
HelloWorldFunctionRole-11ZOGSCG28H0M
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://njzfhdmls0.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:sam-app-
HelloWorldFunction-XPqNX4TBu7qn
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app-zip in us-west-2
```
1. Para ver la aplicación implementada, haga lo siguiente:
1. [Abra la CloudFormation consola directamente con la URL https://console.aws.amazon.com /cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleccione **Stacks** (Pilas).
1. Identifique su pila por el nombre de la aplicación y selecciónela.
### Comprueba los cambios antes de la implementación
Puede configurarlo AWS SAMCLI para que muestre el conjunto de CloudFormation cambios y solicite una confirmación antes de implementarlo.
**Para confirmar los cambios antes de la implementación**
1. Durante `sam deploy --guided`, introduzca **Y** para confirmar los cambios antes de la implementación.
```
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: Y
```
Como alternativa, puede modificar el archivo `samconfig.toml` con lo siguiente:
```
[default.deploy]
[default.deploy.parameters]
confirm_changeset = true
```
1. Durante la implementación, la AWS SAM de CLI le pedirá que confirme los cambios antes de la implementación. A continuación, se muestra un ejemplo:
```
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
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
```
### Especifica parámetros adicionales durante la implementación
Puedes especificar valores de parámetros adicionales para configurarlos durante la implementación. Para ello, modifique la plantilla de AWS SAM y configure el valor del parámetro durante la implementación.
**Para especificar parámetros adicionales**
1. Modifique la `Parameters` sección de la AWS SAM plantilla. A continuación, se muestra un ejemplo:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Globals:
...
Parameters:
DomainName:
Type: String
Default: example
Description: Domain name
```
1. Ejecute `sam deploy --guided`. El siguiente es un ejemplo de output:
```
sam-app $ 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 [sam-app-zip]: ENTER
AWS Region [us-west-2]: ENTER
Parameter DomainName [example]: ENTER
```
### Configura la firma de código para las funciones de Lambda
Puede configurar la firma de código para las funciones de Lambda en el momento de la implementación. Para ello, modifique la AWS SAM plantilla y configure la firma de código durante la implementación.
**Para configurar la firma de código**
1. Especifica `CodeSigningConfigArn` en tu AWS SAM plantilla. A continuación, se muestra un ejemplo:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: arn:aws:lambda:us-east-1:111122223333:code-signing-config:csc-12e12345db1234567
```
1. Ejecute `sam deploy --guided`. La CLI de AWS SAM le pedirá que configure la firma de código. El siguiente es un ejemplo de output:
```
#Found code signing configurations in your function definitions
Do you want to sign your code? [Y/n]: ENTER
#Please provide signing profile details for the following functions & layers
#Signing profile details for function 'HelloWorld'
Signing Profile Name:
Signing Profile Owner Account ID (optional):
#Signing profile details for layer 'MyLayer', which is used by functions {'HelloWorld'}
Signing Profile Name:
Signing Profile Owner Account ID (optional):
```
## Prácticas recomendadas
+ Cuando se usa `sam deploy`, la CLI de AWS SAM implementa los artefactos de compilación de la aplicación ubicados en el directorio `.aws-sam`. Cuando realice cambios en los archivos originales de la aplicación, ejecútela con `sam build` para actualizar el directorio `.aws-sam` antes de implementarla.
+ Al implementar una aplicación por primera vez, utilícela con `sam deploy --guided` para configurar los ajustes de implementación. Para las implementaciones posteriores, puede utilizar `sam deploy` para realizar la implementación con los parámetros configurados.
## Opciones para una implementación de sam
A continuación, se indican las opciones más utilizadas para `sam deploy`. Para obtener una lista de todas las opciones, consulta [sam deploy](sam-cli-command-reference-sam-deploy.md).
### Utiliza el flujo interactivo guiado para implementar la aplicación
Utiliza la opción `--guided` para configurar los ajustes de implementación de la aplicación mediante un flujo interactivo. A continuación, se muestra un ejemplo:
```
$ sam deploy --guided
```
La configuración de implementación de la aplicación se guarda en el archivo `samconfig.toml` del proyecto. Para obtener más información, consulta [Configurar los ajustes del proyecto](using-sam-cli-configure.md#using-sam-cli-configure-project).
## Resolución de problemas
Para solucionar el problema AWS SAMCLI, consulte[Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md).
## Ejemplos
### Implemente una aplicación Hello World que contenga una función de Lambda empaquetada como un archivo.zip
Para ver un ejemplo, consulta el tutorial [Paso 3: Implemente la aplicación en Nube de AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy) de la aplicación Hello World.
### Implemente una aplicación Hello World que contenga una función de Lambda empaquetada como imagen de contenedor
En primer lugar, cree la aplicación Hello World. `sam init` Durante el flujo interactivo, elija el tiempo de ejecución `Python3.9` y el tipo de paquete `Image`.
```
$ 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]: ENTER
Which runtime would you like to use?
1 - aot.dotnet7 (provided.al2)
...
15 - nodejs12.x
16 - python3.9
17 - python3.8
...
Runtime: 16
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is pip.
We will proceed copying the template using pip.
...
Project name [sam-app]: ENTER
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/python3.9-base
Architectures: x86_64
Dependency Manager: pip
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
A continuación, vaya al directorio raíz `cd` del proyecto y ejecútelo con `sam build`. La CLI de AWS SAM crea la función de Lambda localmente usando Docker.
```
sam-app $ sam build
Building codeuri: /Users/.../sam-app runtime: None metadata: {'Dockerfile': 'Dockerfile', 'DockerContext': '/Users/.../sam-app/hello_world', 'DockerTag': 'python3.9-v1'} architecture: x86_64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/5 : FROM public.ecr.aws/lambda/python:3.9
---> 0a5e3da309aa
Step 2/5 : COPY requirements.txt ./
---> abc4e82e85f9
Step 3/5 : RUN python3.9 -m pip install -r requirements.txt -t .
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in 43845e7aa22d
Collecting requests
Downloading requests-2.28.2-py3-none-any.whl (62 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.8/62.8 KB 829.5 kB/s eta 0:00:00
Collecting idna<4,>=2.5
Downloading idna-3.4-py3-none-any.whl (61 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 61.5/61.5 KB 2.4 MB/s eta 0:00:00
Collecting charset-normalizer<4,>=2
Downloading charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (199 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 199.2/199.2 KB 2.1 MB/s eta 0:00:00
Collecting certifi>=2017.4.17
Downloading certifi-2022.12.7-py3-none-any.whl (155 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 155.3/155.3 KB 10.2 MB/s eta 0:00:00
Collecting urllib3<1.27,>=1.21.1
Downloading urllib3-1.26.15-py2.py3-none-any.whl (140 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 140.9/140.9 KB 9.1 MB/s eta 0:00:00
Installing collected packages: urllib3, idna, charset-normalizer, certifi, requests
Successfully installed certifi-2022.12.7 charset-normalizer-3.1.0 idna-3.4 requests-2.28.2 urllib3-1.26.15
Removing intermediate container 43845e7aa22d
---> cab8ace899ce
Step 4/5 : COPY app.py ./
---> 4146f3cd69f2
Step 5/5 : CMD ["app.lambda_handler"]
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in f4131ddffb31
Removing intermediate container f4131ddffb31
---> d2f5180b2154
Successfully built d2f5180b2154
Successfully tagged helloworldfunction:python3.9-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
A continuación, ejecuta `sam deploy --guided` para crear e implementar la aplicación. La CLI de AWS SAM lo guía a través de la configuración de los ajustes de implementación. Luego, AWS SAMCLI despliega nuestra aplicación en. Nube de AWS
```
sam-app $ 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 [sam-app]: 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]: ENTER
#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:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
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
e95fc5e75742: Pushed
d8df51e7bdd7: Pushed
b1d0d7e0b34a: Pushed
0071317b94d8: Pushed
d98f98baf147: Pushed
2d244e0816c6: Pushed
eb2eeb1ebe42: Pushed
a5ca065a3279: Pushed
fe9e144829c9: Pushed
helloworldfunction-d2f5180b2154-python3.9-v1: digest: sha256:cceb71401b47dc3007a7a1e1f2e0baf162999e0e6841d15954745ecc0c447533 size: 2206
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment image repository :
{
"HelloWorldFunction": "012345678910.dkr.ecr.us-west-2.amazonaws.com/samapp7427b055/helloworldfunction19d43fc4repo"
}
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
HelloWorldFunction may not have authorization defined.
Uploading to sam-app/682ad27c7cf7a17c7f77a1688b0844f2.template 1328 / 1328 (100.00%)
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
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680634124/0ffd4faf-2e2b-487e-b9e0-9116e8299ac4
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-04 08:49:15 - 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::S sam-app User Initiated
tack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-JFML1JOKHJ71
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://endlwiqqod.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:sam-app-HelloWorldFunction-
kyg6Y2iNRUPg
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app in us-west-2
```
## Más información
Para obtener más información sobre el uso del AWS SAMCLI `sam deploy` comando, consulte lo siguiente:
+ **[El AWS SAM taller completo: Módulo 3: Implementación manual](https://s12d.com/sam-ws-en-manual-deploy)**: aprenda a crear, empaquetar e implementar una aplicación sin servidor mediante el AWS SAMCLI.
# Opciones para implementar su aplicación con AWS SAM
Con él AWS SAM, puede implementar su aplicación manualmente y automatizar las implementaciones. Use la CLI de AWS SAM para implementar la aplicación manualmente. Para automatizar la implementación, use canalizaciones y un sistema de implementación e integración continuas (CI/CD). En los temas de esta sección se proporciona información sobre ambos enfoques.
**Topics**
+ [Cómo usar la CLI de AWS SAM para realizar una implementación manual](#serverless-sam-cli-using-package-and-deploy)
+ [Implemente con CI/CD sistemas y canalizaciones](#serverless-deploying-ci-cd)
+ [Implementación gradual](#serverless-deploying-gradual)
+ [Solución de problemas de las implementaciones mediante la CLI de AWS SAM](#serverless-deploying-troubleshooting)
+ [Más información](#serverless-sam-cli-using-invoke-learn)
## Cómo usar la CLI de AWS SAM para realizar una implementación manual
Después de desarrollar y testar la aplicación sin servidor a nivel local, puedes implementarla mediante el comando **[sam deploy](sam-cli-command-reference-sam-deploy.md)**.
Para AWS SAM guiarlo a lo largo de la implementación con instrucciones, especifique el **--guided** indicador. Al especificar este indicador, el comando **sam deploy** comprime los artefactos de la aplicación y los carga en Amazon Simple Storage Service (Amazon S3) (para archivos de archivos .zip) o en Amazon Elastic Container Registry (Amazon ECR) (para imágenes de contenedores). A continuación, el comando despliega la aplicación en la AWS nube.
**Ejemplo:**
```
# Deploy an application using prompts:
sam deploy --guided
```
## Implemente con CI/CD sistemas y canalizaciones
AWS SAM le ayuda a automatizar la implementación mediante canalizaciones y un sistema de integración e implementación continuas (CI/CD). AWS SAM se puede utilizar para crear canalizaciones y simplificar las CI/CD tareas de las aplicaciones sin servidor. Varios CI/CD sistemas admiten la AWS SAM creación de imágenes de contenedores y AWS SAM también proporcionan un conjunto de plantillas de canalización predeterminadas para varios CI/CD sistemas que encapsulan las mejores prácticas AWS de implementación.
Para obtener más información, consulte [Uso CI/CD de sistemas y canalizaciones para implementar con AWS SAM](deploying-cicd-overview.md).
## Implementación gradual
Si desea implementar la AWS SAM aplicación de forma gradual en lugar de hacerlo de una sola vez, puede especificar las configuraciones de implementación que se AWS CodeDeploy proporcionan. Para obtener más información, consulte [Trabajar con configuraciones de despliegue CodeDeploy en](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html) la *Guía del AWS CodeDeploy usuario*.
Para obtener información sobre cómo configurar AWS SAM la aplicación para que se despliegue de forma gradual, consulte[Implementación gradual de aplicaciones sin servidor con AWS SAM](automating-updates-to-serverless-apps.md).
## Solución de problemas de las implementaciones mediante la CLI de AWS SAM
### Error de la CLI de AWS SAM: «no se cumplen las restricciones de seguridad»
Al ejecutar **sam deploy --guided**, se le preguntará `HelloWorldFunction may not have authorization defined, Is this okay? [y/N]`. Si respondes a esta solicitud con **N** (la respuesta predeterminada), verás el siguiente error:
```
Error: Security Constraints Not Satisfied
```
El mensaje le informa de que la aplicación que va a implementar podría tener una API de Amazon API Gateway de acceso público configurada sin autorización. Al responder **N** a esta pregunta, está diciendo que esto no está bien.
Para resolver este problema, dispones de las siguientes opciones:
+ Configura tu aplicación con autorización. Para obtener más información acerca de la autorización, consulta [Controla el acceso a la API con tu AWS SAM plantilla](serverless-controlling-access-to-apis.md).
+ Responde a esta pregunta **Y** para indicar que estás de acuerdo con la implementación de una aplicación que tenga una API de API Gateway configurada sin autorización.
## Más información
Para ver ejemplos prácticos de la implementación de aplicaciones sin servidor, consulte lo siguiente de *The Complete AWS SAM * Workshop:
+ [Módulo 3: Implementación manual](https://s12d.com/sam-ws-en-manual-deploy): aprenda a crear, empaquetar e implementar una aplicación sin servidor mediante. AWS SAMCLI
+ [Módulo 4: CI/CD](https://s12d.com/sam-ws-en-cicd-deploy): aprenda a automatizar las fases de creación, empaquetado e implementación mediante la creación de una canalización de *integración y entrega continuas (CI/CD)*.
# 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)
# Introducción al uso sam sync de la sincronización con Nube de AWS
El AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam sync` ofrece opciones para sincronizar rápidamente los cambios de la aplicación local con el Nube de AWS. Utiliza `sam sync` al desarrollar sus aplicaciones para:
1. Detecta y sincroniza automáticamente los cambios locales en Nube de AWS.
1. Personalizar los cambios locales que se sincronizan con la Nube de AWS.
1. Preparar tu aplicación en la nube para probarla y validarla.
Con `sam sync`, puede crear un flujo de trabajo de desarrollo rápido que reduzca el tiempo necesario para sincronizar los cambios locales con la nube para realizar pruebas y validaciones.
**nota**
Se recomienda usar el comando `sam sync` para entornos de desarrollo. Para los entornos de producción, recomendamos usar `sam deploy` o configurar una canalización de *integración y entrega continuas (CI/CD)*. Para obtener más información, consulte [Implemente su aplicación y sus recursos con AWS SAM](serverless-deploying.md).
El `sam sync` comando forma parte de AWS SAM Accelerate. *AWS SAM Accelerate*proporciona herramientas que puede utilizar para acelerar la experiencia de desarrollo y prueba de aplicaciones sin servidor en. Nube de AWS
**Topics**
+ [Detecte y sincronice automáticamente los cambios locales en el Nube de AWS](#using-sam-cli-sync-auto)
+ [Personalice los cambios locales que se sincronizan con el Nube de AWS](#using-sam-cli-sync-customize)
+ [Preparar tu aplicación en la nube para probarla y validarla.](#using-sam-cli-sync-test)
+ [Opciones para el comando de sincronización sam](#using-sam-cli-sync-options)
+ [Resolución de problemas](#using-sam-cli-sync-troubleshooting)
+ [Ejemplos](#using-sam-cli-sync-examples)
+ [Más información](#using-sam-cli-sync-learn)
## Detecte y sincronice automáticamente los cambios locales en el Nube de AWS
Ejecute `sam sync` con la opción `--watch` para comenzar a sincronizar tu aplicación con la Nube de AWS. Esto hace lo siguiente:
1. **Crear tu aplicación**: este proceso es similar a usar el comando `sam build`.
1. **Implementar tu aplicación**: la CLI de AWS SAM implementa tu aplicación en AWS CloudFormation utilizando su configuración predeterminada. Se usan los siguientes valores predeterminados:
1. AWS las credenciales y los ajustes de configuración generales que se encuentran en la carpeta `.aws` de usuario.
1. La configuración de implementación de la aplicación se encuentra en el archivo `samconfig.toml` de la aplicación.
Si no se encuentran los valores predeterminados, la CLI de AWS SAM se lo comunicará y saldrá del proceso de sincronización.
1. **Esté atento a los cambios locales**: la CLI de AWS SAM sigue ejecutándose y vigila los cambios locales en tu aplicación. Esto es lo que ofrece la opción `--watch`.
Esta opción puede que esté activada de forma predeterminada. Para ver los valores predeterminados, consulta el archivo `samconfig.toml` de tu aplicación. A continuación se muestra un ejemplo de un archivo:
```
...
[default.sync]
[default.sync.parameters]
watch = true
...
```
1. **Sincronizar los cambios locales con el Nube de AWS**: cuando realizas cambios locales, AWS SAMCLI detecta y sincroniza esos cambios con el Nube de AWS método más rápido disponible. Según el tipo de cambio, puede ocurrir lo siguiente:
1. Si el recurso actualizado es compatible con el AWS servicio APIs, lo AWS SAMCLI usará para implementar los cambios. Esto da como resultado una sincronización rápida para actualizar el recurso en la Nube de AWS.
1. Si el recurso actualizado no es compatible con el AWS servicio APIs, AWS SAMCLI realizará una CloudFormation implementación. Esto actualiza toda la aplicación en la Nube de AWS. Si bien no es tan rápido, evita que tenga que iniciar una implementación manualmente.
Como el `sam sync` comando actualiza automáticamente la aplicación en el Nube de AWS, solo se recomienda su uso en entornos de desarrollo. Cuando ejecuta `sam sync`, se le pedirá que confirme:
```
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]: ENTER
```
## Personalice los cambios locales que se sincronizan con el Nube de AWS
Proporcionar opciones para personalizar los cambios locales que se sincronizan con la Nube de AWS. Esto puede acelerar el tiempo que se tarda en ver los cambios locales en la nube para probarlos y validarlos.
Por ejemplo, ofrezca la `--code` opción de sincronizar solo los cambios de código, como el código de AWS Lambda función. Durante el desarrollo, si se centra específicamente en el código Lambda, sus cambios llegarán rápidamente a la nube para probarlos y validarlos. A continuación, se muestra un ejemplo:
```
$ sam sync --code --watch
```
Para sincronizar solo los cambios de código de una función o capa de Lambda específica, utiliza la opción `--resource-id`. A continuación, se muestra un ejemplo:
```
$ sam sync --code --resource-id HelloWorldFunction --resource-id HelloWorldLayer
```
## Preparar tu aplicación en la nube para probarla y validarla.
El comando `sam sync` busca automáticamente el método más rápido disponible para actualizar la aplicación en la Nube de AWS. Esto puede acelerar sus flujos de trabajo de desarrollo y pruebas en la nube. Al utilizar el AWS servicio APIs, puede desarrollar, sincronizar y probar rápidamente los recursos compatibles. Para ver un ejemplo práctico, consulte el [Módulo 6: AWS SAM Accelerate](https://s12d.com/sam-ws-en-accelerate) in *The Complete AWS SAM Workshop*.
## Opciones para el comando de sincronización sam
Las siguientes son algunas de las opciones principales que puede utilizar para modificar el comando `sam sync`. Para obtener una lista de todas las opciones, consulta [sam sync](sam-cli-command-reference-sam-sync.md).
### Realice un CloudFormation despliegue único
Usa la opción `--no-watch` para desactivar la sincronización automática. A continuación, se muestra un ejemplo:
```
$ sam sync --no-watch
```
AWS SAMCLIRealizará un CloudFormation despliegue único. Este comando agrupa las acciones realizadas por los comandos `sam build` y `sam deploy`.
### Omita la CloudFormation implementación inicial
Puede personalizar si se requiere una CloudFormation implementación cada vez que `sam sync` se ejecute.
+ Asegúrese `--no-skip-deploy-sync` de requerir una CloudFormation implementación cada vez `sam sync` que se ejecute. Esto garantiza que su infraestructura local esté sincronizada CloudFormation, lo que evita desviaciones. El uso de esta opción añade tiempo adicional a su flujo de trabajo de desarrollo y pruebas.
+ Proporcione esta opción `--skip-deploy-sync` para que la CloudFormation implementación sea opcional. AWS SAMCLIComparará su AWS SAM plantilla local con la CloudFormation plantilla implementada y omitirá la CloudFormation implementación inicial si no se detecta ningún cambio. Omitir la CloudFormation implementación puede ahorrarle tiempo a la hora de sincronizar los cambios locales con la. Nube de AWS
Si no se detecta ningún cambio, AWS SAMCLI seguirá realizando un CloudFormation despliegue en los siguientes escenarios:
+ Si han pasado 7 días o más desde la última CloudFormation implementación.
+ Si se detecta una gran cantidad de cambios en el código de la función Lambda, la CloudFormation implementación es el método más rápido para actualizar la aplicación.
A continuación, se muestra un ejemplo:
```
$ sam sync --skip-deploy-sync
```
### Sincronice un recurso de una pila anidada
**Para sincronizar un recurso de una pila anidada**
1. Proporciona la pila raíz utilizando `--stack-name`.
1. Identifique el recurso en la pila anidada con el siguiente formato: `nestedStackId/resourceId`.
1. Proporciona el recurso en la pila anidada usando `--resource-id`.
A continuación, se muestra un ejemplo:
```
$ sam sync --code --stack-name sam-app --resource-id myNestedStack/HelloWorldFunction
```
Para obtener más información sobre cómo crear aplicaciones anidadas, consulta [Reutilice el código y los recursos mediante aplicaciones anidadas en AWS SAM](serverless-sam-template-nested-applications.md).
### Especifique una CloudFormation pila específica para actualizar
Para especificar una CloudFormation pila específica para actualizarla, proporcione la `--stack-name` opción. A continuación, se muestra un ejemplo:
```
$ sam sync --stack-name dev-sam-app
```
### Acelere los tiempos de compilación al compilar el proyecto en la carpeta de origen
Para consultar los tiempos de ejecución y los métodos de compilación compatibles, puedes usar la opción de `--build-in-source` para compilar el proyecto directamente en la carpeta de origen. De forma predeterminada, se AWS SAM CLI compila en un directorio temporal, lo que implica copiar el código fuente y los archivos del proyecto. Con `--build-in-source` las AWS SAM CLI compilaciones directamente en la carpeta de origen, lo que acelera el proceso de compilación al eliminar la necesidad de copiar los archivos a un directorio temporal.
Para obtener una lista de tiempos de ejecución y métodos de compilación compatibles, consulta ` --build-in-source`.
### Especificar archivos y carpetas que no iniciarán una sincronización
Utiliza la opción `--watch-exclude` para especificar cualquier archivo o carpeta que no iniciará una sincronización cuando se actualice. Para obtener más información acerca de esta opción, consulta `--watch-exclude`.
El siguiente es un ejemplo que excluye el archivo `package-lock.json` asociado a nuestra función de `HelloWorldFunction`:
```
$ sam sync --watch --watch-exclude HelloWorldFunction=package-lock.json
```
Cuando se ejecute este comando, AWS SAM CLI se iniciará el proceso de sincronización. Esta incluye lo siguiente:
+ Ejecute `sam build` para crear las funciones y preparar la aplicación para la implementación.
+ Ejecute `sam deploy` para implementar la aplicación.
+ Esté atento a los cambios en la aplicación.
Cuando modifiquemos el `package-lock.json` archivo, AWS SAM CLI no se iniciará la sincronización. Cuando se actualice otro archivo, AWS SAM CLI se iniciará una sincronización, que incluirá el `package-lock.json` archivo.
El siguiente es un ejemplo de cómo especificar una función de Lambda de una pila secundaria:
```
$ sam sync --watch --watch-exclude ChildStackA/MyFunction=database.sqlite3
```
## Resolución de problemas
Para solucionar problemas de AWS SAMCLI, consulte[Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md).
## Ejemplos
### Uso de sam sync para actualizar la aplicación Hello World
En este ejemplo, empezamos inicializando la aplicación de muestra Hello World. Para obtener más información sobre esta aplicación, consulta [Tutorial: Implemente una aplicación Hello World con AWS SAM](serverless-getting-started-hello-world.md).
Ejecutar `sam sync` inicia el proceso de creación e implementación.
```
$ sam sync
The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without
performing a CloudFormation deployment. This will cause drift in your CloudFormation stack.
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]:
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/0663e6fe-a888-4efb-b908-e2344261e9c7) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 11:17:19 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt Resource creation Initiated
ack
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d Resource creation Initiated
5f9d
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.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:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack creation succeeded. Sync infra completed.
Infra sync completed.
CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi.
```
Una vez completada la implementación, modificamos el código `HelloWorldFunction`. AWS SAMCLIDetecta este cambio y sincroniza nuestra aplicación con. Nube de AWS Como AWS Lambda es compatible con APIs el AWS servicio, se realiza una sincronización rápida.
```
Syncing Lambda Function HelloWorldFunction...
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Finished syncing Lambda Function HelloWorldFunction.
```
A continuación, modificamos nuestro punto final de API en la AWS SAM plantilla de la aplicación. Cambiamos `/hello` por `/helloworld`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
...
Properties:
...
Events:
HelloWorld:
Type: Api
Properties:
Path: /helloworld
Method: get
```
Como el recurso Amazon API Gateway no es compatible con la API de AWS servicio, realiza una CloudFormation implementación AWS SAMCLI automáticamente. El siguiente es un ejemplo de output:
```
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9 --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 14:41:18 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
UPDATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Requested update requires the
ssionProd creation of a new physical
resource; hence creating one.
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e Resource creation Initiated
d3cd
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app -
SS
DELETE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
DELETE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
DELETE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
DELETE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.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:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack update succeeded. Sync infra completed.
Infra sync completed.
```
## Más información
Para ver una descripción de las opciones de `sam sync`, consulta [sam sync](sam-cli-command-reference-sam-sync.md).