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. # Tutorial: Implemente una aplicación Hello World con AWS SAM En este tutorial, utilizará la interfaz de línea de AWS Serverless Application Model comandos (AWS SAMCLI) para realizar lo siguiente: + Inicializa, crea e implementa una aplicación de muestra **Hello World** + Realice cambios locales y sincronícelos con AWS CloudFormation. + Haga pruebas locales en el host de desarrollo. + Elimina la aplicación de muestra de la Nube de AWS. La aplicación de muestra **Hello World** implementa un backend de API básico. Consta de los recursos siguientes: + **Amazon API Gateway**: punto de conexión de la API que utilizarás para invocar tu función. + **AWS Lambda**: función que procesa la solicitud HTTP API GET y devuelve el mensaje `hello world`. + **AWS Identity and Access Management Función (IAM): proporciona** permisos para que los servicios interactúen de forma segura. El siguiente diagrama muestra los componentes de esta aplicación: ![\[Diagrama de una función de Lambda que se invoca cuando envía una solicitud GET al punto de conexión de la API Gateway.\]](http://docs.aws.amazon.com/es_es/serverless-application-model/latest/developerguide/images/gs-01.png) **Topics** + [ ## Requisitos previos ](#serverless-getting-started-hello-world-prerequisites) + [ ## Paso 1: inicializar la aplicación de muestra Hello World ](#serverless-getting-started-hello-world-init) + [ ## Paso 2: crear tu propia aplicación ](#serverless-getting-started-hello-world-build) + [ ## Paso 3: Implemente la aplicación en Nube de AWS ](#serverless-getting-started-hello-world-deploy) + [ ## Paso 4: ejecutar la aplicación ](#serverless-getting-started-hello-world-run) + [ ## Paso 5: Interactúa con tu función en el Nube de AWS ](#serverless-getting-started-hello-world-remote-invoke) + [ ## Paso 6: Modifique y sincronice su aplicación con Nube de AWS ](#serverless-getting-started-hello-world-sync) + [ ## Paso 7: (opcional) probar tu aplicación localmente ](#serverless-getting-started-hello-world-test) + [ ## Paso 8: Elimine la aplicación del Nube de AWS ](#serverless-getting-started-hello-world-delete) + [ ## Resolución de problemas ](#serverless-getting-started-hello-world-troubleshoot) + [ ## Más información ](#serverless-getting-started-hello-world-learn) ## Requisitos previos Asegúrate de haber completado lo siguiente: + [AWS SAM requisitos previos](prerequisites.md) + [Instala la AWS SAM CLI](install-sam-cli.md) **nota** Si prefiere usar Visual Studio Code para el desarrollo sin servidor, consulte [Creación de aplicaciones sin servidor](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/sam-get-started.html#serverless-apps-create) en la Guía del usuario del AWS Toolkit for VS Code para obtener instrucciones sobre el uso de la step-by-step interfaz VS Code. ## Paso 1: inicializar la aplicación de muestra Hello World En este paso, utilizarás la AWS SAM CLI para crear un proyecto de aplicación de muestra **Hello World** en su unidad local. **Para inicializar la aplicación de muestra Hello World** 1. En la línea de comandos, ejecuta lo siguiente desde el directorio de inicio que desees: ``` $ sam init ``` **nota** Este comando inicializa la aplicación sin servidor y crea el directorio del proyecto. El directorio contiene varios archivos y carpetas, incluido el `template.yaml` archivo, que es su AWS SAM plantilla. La versión de Python instalada debe coincidir con la propiedad `Runtime` especificada en`template.yaml`. Para las cargas de trabajo de producción, recomendamos usar Python 3.12 o versiones anteriores que sean totalmente compatibles con los entornos AWS . Si las versiones de Python no coinciden, se producirán errores de compilación. Para resolver problemas de compatibilidad de versiones: Especifique un [tiempo de ejecución](sam-cli-command-reference-sam-init.md#sam-cli-command-reference-sam-init-options-runtime) compatible durante la inicialización: `sam init --runtime python3.9` Modifique la propiedad `Runtime` en `template.yaml` después de la inicialización 1. La AWS SAM CLI te guiará a través de la inicialización de una nueva aplicación. Configura lo siguiente: 1. Selecciona **Plantillas de inicio rápido de AWS ** para elegir una plantilla de inicio. 1. Selecciona la plantilla **Ejemplo de Hello World** y descárgala. 1. Usa el tiempo de ejecución de Python y el tipo de paquete `zip`. 1. Para este tutorial, opte por no participar en el rastreo. AWS X-Ray Para obtener más información, consulte [¿Qué es? AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) en la *Guía para AWS X-Ray desarrolladores*. 1. Para este tutorial, opte por no monitorizar con Amazon CloudWatch Application Insights. Para obtener más información, consulte [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) en la *Guía del CloudWatch usuario de Amazon*. 1. Para este tutorial, debe desactivar el parámetro de registro estructurado en formato JSON en las funciones de Lambda. 1. Asigna el nombre **sam-app** a tu aplicación. Para usar el flujo interactivo de la CLI de AWS SAM: + Los corchetes (`[ ]`) indican los valores predeterminados. Deja la respuesta en blanco para seleccionar el valor predeterminado. + Escribe **`y`** para **sí** y **`n`** para **no**. A continuación, se muestra un ejemplo de flujo interactivo con `sam init`. ``` $ 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 - Data processing 3 - Hello World Example with Powertools for AWS Lambda 4 - Multi-step workflow 5 - Scheduled task 6 - Standalone function 7 - Serverless API 8 - Infrastructure event management 9 - Lambda Response Streaming 10 - GraphQLApi Hello World Example 11 - Full Stack 12 - Lambda EFS example 13 - Serverless Connector Hello World Example 14 - Multi-step workflow with Connectors 15 - DynamoDB Example 16 - Machine Learning 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 Would you like to set Structured Logging in JSON format on your Lambda functions? [y/N]: ENTER Project name [sam-app]: ENTER ``` 1. AWS SAMCLIDescarga la plantilla inicial y crea la estructura de directorios del proyecto de la aplicación en su máquina local. A continuación, se muestra un ejemplo de resultados del AWS SAM CLI output. ``` Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment) ----------------------- Generating application: ----------------------- Name: sam-app Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: sam-app/samconfig.toml Next steps can be found in the README file at sam-app/README.md Commands you can use next ========================= [*] Create pipeline: cd sam-app && sam pipeline init --bootstrap [*] Validate SAM template: cd sam-app && sam validate [*] Test Function in the Cloud: cd sam-app && sam sync --stack-name {stack-name} --watch ``` 1. Desde la línea de comandos, dirígete al directorio `sam-app` recién creado. A continuación se muestra un ejemplo de lo que la CLI de AWS SAM ha creado: **nota** Si el comando `tree` no se instala automáticamente, ejecute este comando: `brew install tree` ``` $ cd sam-app $ tree ├── README.md ├── __init__.py ├── events │ └── event.json ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── samconfig.toml ├── template.yaml └── tests ├── __init__.py ├── integration │ ├── __init__.py │ └── test_api_gateway.py ├── requirements.txt └── unit ├── __init__.py └── test_handler.py 6 directories, 14 files ``` Algunos archivos importantes que hay que destacar: + `hello_world/app.py`: contiene el código de tu función de Lambda. + `hello_world/requirements.txt`: contiene cualquier dependencia de Python que tu función de Lambda necesite. + `samconfig.toml`— Archivo de configuración para su aplicación que almacena los parámetros predeterminados utilizados por AWS SAMCLI. + `template.yaml`— La AWS SAM plantilla que contiene el código de infraestructura de la aplicación. ¡Ya tienes una aplicación sin servidor creada enteramente en tu equipo local\$1 ## Paso 2: crear tu propia aplicación En este paso, usa AWS SAM CLI para crear la aplicación y prepararla para la implementación. Mientras la está creando, la de AWS SAM CLI crea un directorio de `.aws-sam` y organiza allí las dependencias de las funciones, el código del proyecto y los archivos del proyecto. **Para crear tu aplicación** + En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam build ``` **nota** Si no tienes Python en tu equipo local, usa el comando **sam build --use-container ** en su lugar. La AWS SAM CLI creará un contenedor de Docker que incluye el tiempo de ejecución y las dependencias de tu función. Este comando requiere que tengas Docker en tu equipo local. Para instalarDocker, consulta [Instalar Docker](install-docker.md). A continuación, se muestra un ejemplo de resultados de la CLI de AWS SAM. ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/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 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 ``` El siguiente es un ejemplo abreviado del directorio de `.aws-sam` creado por la CLI de AWS SAM : ``` .aws-sam ├── build │ ├── HelloWorldFunction │ │ ├── __init__.py │ │ ├── app.py │ │ └── requirements.txt │ └── template.yaml └── build.toml ``` Algunos archivos importantes que hay que destacar: + `build/HelloWorldFunction`: contiene el código y las dependencias de tu función de Lambda. La AWS SAM CLI crea un directorio para cada función de tu aplicación. + `build/template.yaml`— Contiene una copia de la AWS SAM plantilla a la que se hace referencia CloudFormation en el momento de la implementación. + `build.toml`: archivo de configuración que almacena los valores de los parámetros predeterminados a los que hace referencia la AWS SAM CLI al crear e implementar la aplicación. Ahora estás listo o lista para implementar la aplicación en la Nube de AWS. ## Paso 3: Implemente la aplicación en Nube de AWS **nota** Este paso requiere la configuración de AWS las credenciales. Para obtener más información, consulta [Paso 5: utilícelo AWS CLI para configurar AWS las credenciales](prerequisites.md#prerequisites-configure-credentials) en [AWS SAM requisitos previos](prerequisites.md). En este paso, utiliza la AWS SAM CLI para implementar la aplicación en la Nube de AWS. AWS SAMCLIHará lo siguiente: + Guiarte a través de la configuración de los ajustes de la aplicación para la implementación. + Cargar tus archivos de aplicación en Amazon Simple Storage Service (Amazon S3). + Transforma tu AWS SAM plantilla en una CloudFormation plantilla. A continuación, carga la plantilla en el CloudFormation servicio para aprovisionar AWS los recursos. **Para implementar la aplicación** 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam deploy --guided ``` 1. Sigue el flujo interactivo de la CLI de AWS SAM para configurar los ajustes de la aplicación. Configura lo siguiente: 1. El **nombre de la CloudFormation pila**: una pila es un conjunto de AWS recursos que puedes gestionar como una sola unidad. Para obtener más información, consulta [Trabajar con pilas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacks.html) en la *Guía del usuario de AWS CloudFormation *. 1. El **Región de AWS**lugar en el que desplegar tu CloudFormation pila. Para obtener más información, consulta [CloudFormation Puntos de conexión de](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-endpoints.html) en la *AWS CloudFormation Guía de usuario*. 1. Para este tutorial, desactiva **confirmar los cambios antes de la implementación**. 1. Permitir **la creación de funciones de IAM**: permite AWS SAM crear la función de IAM necesaria para que el recurso de API Gateway y el recurso de función de Lambda interactúen. 1. Para este tutorial, desactiva **deshabilitar la reversión**. 1. Permitir **HelloWorldFunction sin autorización definida**: este mensaje se muestra porque su punto final de API Gateway está configurado para ser de acceso público, sin autorización. Dado que esta es la configuración prevista para tu aplicación Hello World, deje que la CLI de AWS SAM continúe. Para obtener más información acerca de la autorización de configuración, consulta [Controla el acceso a la API con tu AWS SAM plantilla](serverless-controlling-access-to-apis.md). 1. **Guardar los argumentos en el archivo de configuración**: esto actualizará el archivo `samconfig.toml` de la aplicación con tus preferencias de implementación. 1. Selecciona el **nombre del archivo de configuración** predeterminado. 1. Selecciona el **entorno de configuración** predeterminado. A continuación se muestra un ejemplo del flujo interactivo `sam deploy --guided`: ``` $ 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]: 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 ``` 1. AWS SAMCLIDespliega la aplicación de la siguiente manera: + La AWS SAM CLI crea un bucket de Amazon S3 y carga el directorio `.aws-sam`. + AWS SAMCLITransforma la AWS SAM plantilla en ella CloudFormation y la carga en el CloudFormation servicio. + CloudFormation aprovisiona sus recursos. Durante la implementación, la AWS SAM CLI muestra tu progreso. El siguiente es un ejemplo de output: ``` 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 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/.../Demo/sam-tutorial1/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 File with same data already exists at sam-app/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : sam-app 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 ===================== File with same data already exists at sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template, skipping upload Waiting for changeset to be created.. CloudFormation stack changeset --------------------------------------------------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement --------------------------------------------------------------------------------------------------------------------------------------------- * Modify HelloWorldFunction AWS::Lambda::Function False * Modify ServerlessRestApi AWS::ApiGateway::RestApi False - Delete AwsSamAutoDependencyLayerNestedSt AWS::CloudFormation::Stack N/A ack --------------------------------------------------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1678917603/22e05525-08f9-4c52-a2c4-f7f1fd055072 2023-03-15 12:00:16 - 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::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app - SS DELETE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack DELETE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack 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-15GLOUR9LMT1W Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://.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-yQDNe17r9maD ---------------------------------------------------------------------------------------------------------------------------------------------- Successfully created/updated stack - sam-app in us-west-2 ``` ¡Su aplicación ya está implementada y ejecutándose en el Nube de AWS\$1 ## Paso 4: ejecutar la aplicación En este paso, enviarás una solicitud GET al punto de conexión de la API y verás el resultado de la función de Lambda. **Para obtener el valor del punto de conexión de tu API** 1. A partir de la información que muestra la AWS SAM CLI en el paso anterior, localiza la sección `Outputs`. En esta sección, localiza tu recurso de `HelloWorldApi` para encontrar el valor del punto de conexión HTTP. El siguiente es un ejemplo de output: ``` ---------------------------------------------------------------------------------------------------------------------------------------------- Outputs ---------------------------------------------------------------------------------------------------------------------------------------------- ... Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ ... ---------------------------------------------------------------------------------------------------------------------------------------------- ``` 1. También puedes utilizar el comando **sam list endpoints --output json** para obtener esta información. El siguiente es un ejemplo de output: ``` $ sam list endpoints --output json 2023-03-15 12:39:19 Loading policies from IAM... 2023-03-15 12:39:25 Finished loading policies from IAM. [ { "LogicalResourceId": "HelloWorldFunction", "PhysicalResourceId": "sam-app-HelloWorldFunction-yQDNe17r9maD", "CloudEndpoint": "-", "Methods": "-" }, { "LogicalResourceId": "ServerlessRestApi", "PhysicalResourceId": "ets1gv8lxi", "CloudEndpoint": [ "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod", "https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Stage" ], "Methods": [ "/hello['get']" ] } ] ``` **Para invocar tu función** + Mediante el navegador o la línea de comandos, envía una solicitud GET al punto de conexión de la API. A continuación, se muestra un ejemplo con el comando curl: ``` $ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ {"message": "hello world"} ``` ## Paso 5: Interactúa con tu función en el Nube de AWS En este paso, utiliza la AWS SAM CLI para invocar la función de Lambda en la Nube de AWS. **Para invocar una función de Lambda en la nube** 1. Toma nota del `LogicalResourceId` de la función del paso anterior. Debería ser `HelloWorldFunction`. 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app ``` 1. AWS SAMCLIInvoca tu función en la nube y devuelve una respuesta. El siguiente es un ejemplo de output: ``` $ sam remote invoke HelloWorldFunction --stack-name sam-app Invoking Lambda Function HelloWorldFunction START RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Version: $LATEST END RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 REPORT RequestId: d5ef494b-5f45-4086-86fd-d7322fa1a1f9 Duration: 6.62 ms Billed Duration: 7 ms Memory Size: 128 MB Max Memory Used: 67 MB Init Duration: 164.06 ms {"statusCode":200,"body":"{\"message\":\"hello world\"}"}% ``` ## Paso 6: Modifique y sincronice su aplicación con Nube de AWS En este paso, utilizará el AWS SAMCLI **sam sync --watch** comando para sincronizar los cambios locales en Nube de AWS. **Para usar la sincronización sam** 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam sync --watch ``` 1. La AWS SAM CLI le pide que confirme que está sincronizando una pila de desarrollo. Como el **sam sync --watch** comando implementa automáticamente los cambios locales Nube de AWS en tiempo real, lo recomendamos únicamente para entornos de desarrollo. La AWS SAM CLI realiza una implementación inicial antes de comenzar a monitorear los cambios locales. El siguiente es un ejemplo de output: ``` $ sam sync --watch 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]: y 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/sam-tutorial1/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/tmpq3x9vh63. Execute the following command to deploy the packaged template sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpq3x9vh63 --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-15 13:10:05 - 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 CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt Resource creation Initiated ack CREATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt - ack UPDATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE AWS::Lambda::Function HelloWorldFunction - UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app - SS 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-15GLOUR9LMT1W Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ets1gv8lxi.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-yQDNe17r9maD ---------------------------------------------------------------------------------------------------------------------------------------------- Stack update succeeded. Sync infra completed. Infra sync completed. CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi. ``` A continuación, modificará el código de tu función de Lambda. AWS SAMCLIDetectará automáticamente este cambio y sincronizará la aplicación con el Nube de AWS. **Para modificar y sincronizar tu aplicación** 1. Abre el archivo `sam-app/hello_world/app.py` con el IDE que prefiera. 1. Cambia el `message` y guarda el archivo. A continuación, se muestra un ejemplo: ``` import json ... def lambda_handler(event, context): ... return { "statusCode": 200, "body": json.dumps({ "message": "hello everyone!", ... }), } ``` 1. AWS SAMCLIDetecta su cambio y sincroniza su aplicación con. Nube de AWS El siguiente es un ejemplo de output: ``` Syncing Lambda Function HelloWorldFunction... Manifest is not changed for (HelloWorldFunction), running incremental build Building codeuri: /Users/.../Demo/sam-tutorial1/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CopySource Finished syncing Lambda Function HelloWorldFunction. ``` 1. Para verificar el cambio, vuelves a enviar una solicitud GET al punto de conexión de la API. ``` $ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/ {"message": "hello everyone!"} ``` ## Paso 7: (opcional) probar tu aplicación localmente **nota** Este paso es opcional. **importante** Este paso requiere que tenga Docker en su equipo local. Debe tener Docker instalado y configurado para utilizar la CLI de AWS SAM para pruebas locales. Para obtener más información, consulte [Instalar Docker](install-docker.md). En este paso, se utiliza el AWS SAMCLI **sam local** comando para probar la aplicación de forma local. Para ello, la AWS SAM CLI crea un entorno local utilizando Docker. Este entorno local emula el entorno de ejecución basado en la nube de tu función de Lambda. Debes hacer lo siguiente: 1. Crea un entorno local para tu función de Lambda e invócala. 1. Aloja tu punto de conexión de la API HTTP localmente y úsalo para invocar tu función de Lambda. **Para invocar una función de Lambda localmente** 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam local invoke ``` 1. La AWS SAM CLI crea un contenedor de Docker local e invoca tu función. El siguiente es un ejemplo de output: ``` $ sam local invoke Invoking app.lambda_handler (python3.9) Local image was not found. Removing rapid images for repo public.ecr.aws/sam/emulation-python3.9 Building image..................... Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container START RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Version: $LATEST END RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 REPORT RequestId: b046db01-2a00-415d-af97-35f3a02e9eb6 Init Duration: 1.01 ms Duration: 633.45 ms Billed Duration: 634 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode": 200, "body": "{\"message\": \"hello world\"}"} ``` **Para alojar tu API de forma local** 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam local start-api ``` 1. La AWS SAM CLI crea un contenedor de Docker local para la función de Lambda y crea un servidor HTTP local para simular el punto de conexión de la API. El siguiente es un ejemplo de output: ``` $ sam local start-api Initializing the lambda functions containers. Local image is up-to-date Using local image: public.ecr.aws/lambda/python:3.9-rapid-x86_64. Mounting /Users/.../Demo/sam-tutorial1/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container Containers Initialization is done. Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET] You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions, changes will be reflected instantly/automatically. If you used sam build before running local commands, you will need to re-run sam build for the changes to be picked up. You only need to restart AWS SAM CLI if you update your AWS SAM template 2023-03-15 14:25:21 WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:3000 2023-03-15 14:25:21 Press CTRL+C to quit ``` 1. Mediante el navegador o la línea de comandos, envía una solicitud GET al punto de conexión de la API local. A continuación, se muestra un ejemplo con el comando curl: ``` $ curl http://127.0.0.1:3000/hello {"message": "hello world"} ``` ## Paso 8: Elimine la aplicación del Nube de AWS En este paso, utilizará el AWS SAMCLI **sam delete** comando para eliminar la aplicación del Nube de AWS. **Para eliminar la aplicación del Nube de AWS** 1. En tu línea de comandos, desde el directorio del proyecto `sam-app`, ejecuta lo siguiente: ``` $ sam delete ``` 1. La AWS SAM CLI le pedirá que confirme. A continuación, eliminará el bucket y la CloudFormation pila de Amazon S3 de la aplicación. El siguiente es un ejemplo de output: ``` $ sam delete Are you sure you want to delete the stack sam-app in the region us-west-2 ? [y/N]: y Are you sure you want to delete the folder sam-app in S3 which contains the artifacts? [y/N]: y - Deleting S3 object with key c6ce8fa8b5a97dd022ecd006536eb5a4 - Deleting S3 object with key 5d513a459d062d644f3b7dd0c8b56a2a.template - Deleting S3 object with key sam-app/2bebf67c79f6a743cc5312f6dfc1efee.template - Deleting S3 object with key sam-app/6b208d0e42ad15d1cee77d967834784b.template - Deleting S3 object with key sam-app/da3c598813f1c2151579b73ad788cac8 - Deleting S3 object with key sam-app/f798cdd93cee188a71d120f14a035b11 - Deleting Cloudformation stack sam-app Deleted successfully ``` ## Resolución de problemas Para solucionar el problema AWS SAMCLI, consulte[Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md). ## Más información Para seguir informándote sobre ellos AWS SAM, consulta los siguientes recursos: + **[El taller completo de AWS SAM](https://s12d.com/sam-ws-en-intro)**: un taller diseñado para enseñarle muchas de las principales características que AWS SAM ofrece. + **[Sesiones con SAM](https://www.youtube.com/playlist?list=PLJo-rJlep0ED198FJnTzhIB5Aut_1vDAd)**: serie de vídeos sobre su uso AWS SAM creada por nuestro equipo de AWS Serverless Developer Advocate. + **[Serverless Land](https://serverlessland.com/)**: sitio que reúne la información más reciente, blogs, vídeos, códigos y recursos de aprendizaje acerca del AWS sin servidor.