Requisitos previos Paso 1: inicializar la aplicación de muestra Hello World Paso 2: crear su aplicación Paso 3: Implemente la aplicación en Nube de AWS Paso 4: ejecutar la aplicación Paso 5: Interactúa con tu función en el Nube de AWS Paso 6: Modifica y sincroniza tu aplicación con Nube de AWS Paso 7: (opcional) probar su aplicación localmente Paso 8: Elimine la aplicación del Nube de AWS Resolución de problemas Más información

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:

Inicialice, cree e implemente una aplicación de muestra Hello World
Realice cambios locales y sincronícelos con AWS CloudFormation.
Realiza pruebas locales en tu host de desarrollo.
Elimine la aplicación de muestra de la Nube de AWS.

La aplicación Hello World de ejemplo implementa un API backend básico. Consta de los recursos siguientes:

Amazon API Gateway: API punto final que utilizará para invocar su función.
AWS Lambda— Función que procesa la HTTP API GET solicitud y devuelve un hello world mensaje.
AWS Identity and Access Management (IAM) rol: 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 Lambda que se invoca al enviar una GET solicitud al punto final de API Gateway.

Temas

Requisitos previos
Paso 1: inicializar la aplicación de muestra Hello World
Paso 2: crear su aplicación
Paso 3: Implemente la aplicación en Nube de AWS
Paso 4: ejecutar la aplicación
Paso 5: Interactúa con tu función en el Nube de AWS
Paso 6: Modifica y sincroniza tu aplicación con Nube de AWS
Paso 7: (opcional) probar su aplicación localmente
Paso 8: Elimine la aplicación del Nube de AWS
Resolución de problemas
Más información

Requisitos previos

Asegúrese de haber completado lo siguiente:

Paso 1: inicializar la aplicación de muestra Hello World

En este paso, utilizará la CLI de AWS SAM para crear un proyecto de aplicación de muestra Hello World en su unidad local.

Para inicializar la aplicación de muestra Hello World

En la línea de comandos, ejecute lo siguiente desde el directorio de inicio que desee:
```
$ sam init
```
nota
Este comando inicializa la aplicación sin servidor y crea el directorio del proyecto. Este directorio contendrá varios archivos y carpetas. El archivo más importante estemplate.yaml. Esta es tu AWS SAM plantilla. Tu versión de python debe coincidir con la versión de python que aparece en el template.yaml archivo que creó el sam init comando.

La CLI de AWS SAM le guiará a través de la inicialización de una nueva aplicación. Configure lo siguiente:

Seleccione Plantillas de inicio rápido de AWS para elegir una plantilla de inicio.
Seleccione la plantilla Ejemplo de Hello World y descárguela.
Use el tiempo de ejecución de Python y el tipo de paquete zip.
Para este tutorial, opta por no usar el AWS X-Ray rastreo. Para obtener más información, consulte ¿Qué es? AWS X-Ray en la Guía para AWS X-Ray desarrolladores.
Para este tutorial, opte por no monitorizar con Amazon CloudWatch Application Insights. Para obtener más información, consulte Amazon CloudWatch Application Insights en la Guía del CloudWatch usuario de Amazon.
Para este tutorial, opte por no configurar el JSON formato de registro estructurado en sus funciones de Lambda.
Asigne a su aplicación el nombre sam-app.

Para usar el flujo interactivo de la CLI de AWS SAM:

Los corchetes ([ ]) indican los valores predeterminados. Deje la respuesta en blanco para seleccionar el valor predeterminado.
Escriba 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 - Multi-step workflow
    3 - Serverless API
    4 - Scheduled task
    5 - Standalone function
    6 - Data processing
    7 - Hello World Example With Powertools
    8 - Infrastructure event management
    9 - Serverless Connector Hello World Example
    10 - Multi-step workflow with Connectors
    11 - Lambda EFS example
    12 - DynamoDB Example
    13 - 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

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 de la CLI de AWS SAM.

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

Desde la línea de comandos, diríjase al directorio sam-app recién creado. A continuación se muestra un ejemplo de lo que la CLI de AWS SAM ha creado:
```
$ 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 su función de Lambda.
- hello_world/requirements.txt: contiene cualquier dependencia de Python que su 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 tiene una aplicación sin servidor creada enteramente en su equipo local!

Paso 2: crear su aplicación

En este paso, use CLI de AWS SAM para crear la aplicación y prepararla para la implementación. Cuando está creando, la CLI de AWS SAM 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 su aplicación

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:


$ sam build

nota

Si no tiene Python en su equipo local, use el comando sam build --use-container en su lugar. La CLI de AWS SAM creará un contenedor de Docker que incluye el tiempo de ejecución y las dependencias de su función. Este comando requiere que Docker esté en su equipo local. Para instalarDocker, consulte Instalar Docker.

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 .aws-sam directorio creado por AWS SAM CLI:

.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 su función de Lambda. La CLI de AWS SAM crea un directorio para cada función de su aplicación.
build/template.yaml— Contiene una copia de la AWS SAM plantilla a la que se hace referencia AWS 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 CLI de AWS SAM al crear e implementar la aplicación.

Ahora está 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, consulte Paso 5: utilice la AWS CLI para configurar AWS credenciales en AWS SAM Requisitos previos de para la de .

En este paso, utilice la CLI de AWS SAM para implementar la aplicación en la Nube de AWS. AWS SAMCLIHará lo siguiente:

Guiarle a través de la configuración de los ajustes de la aplicación para la implementación.
Cargar sus archivos de aplicación en Amazon Simple Storage Service (Amazon S3).
Transforma tu AWS SAM plantilla en una AWS CloudFormation plantilla. A continuación, carga la plantilla en el AWS CloudFormation servicio para aprovisionar AWS los recursos.

Para implementar la aplicación

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam deploy --guided
```
Siga el flujo interactivo de la CLI de AWS SAM para configurar los ajustes de la aplicación. Configure lo siguiente:
1. El nombre de la AWS CloudFormation pila: una pila es un conjunto de AWS recursos que puedes gestionar como una sola unidad. Para obtener más información, consulte Trabajar con pilas en la Guía del usuario de AWS CloudFormation .
2. El Región de AWSlugar en el que desplegar tu AWS CloudFormation pila. Para obtener más información, consulte Puntos de conexión de AWS CloudFormation en la Guía del usuario de AWS CloudFormation .
3. Para este tutorial, desactive confirmar los cambios antes de la implementación.
4. Permitir la creación de IAM roles: esto permite AWS SAM crear el IAM rol necesario para que el recurso de API Gateway y el recurso de función Lambda interactúen.
5. Para este tutorial, desactive deshabilitar la reversión.
6. Permitir HelloWorldFunction sin autorización definida: este mensaje aparece porque el 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 su 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, consulte Controla el API acceso con tu AWS SAM plantilla.
7. Guardar los argumentos en el archivo de configuración: esto actualizará el archivo samconfig.toml de la aplicación con sus preferencias de implementación.
8. Seleccione el nombre del archivo de configuración predeterminado.
9. Seleccione el entorno de configuración predeterminado.
A continuación se muestra un ejemplo del flujo interactivo sam deploy --guided:
```
$ 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]: 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
```

AWS SAMCLIDespliega la aplicación de la siguiente manera:

La CLI de AWS SAM crea un bucket de Amazon S3 y carga el directorio .aws-sam.
AWS SAMCLITransforma la AWS SAM plantilla en ella AWS CloudFormation y la carga en el AWS CloudFormation servicio.
AWS CloudFormation aprovisiona sus recursos.

Durante la implementación, la CLI de AWS SAM muestra su progreso. El siguiente es un ejemplo de salida:

Looking for resources needed for deployment:

    Managed S3 bucket: aws-sam-cli-managed-default-samclisourcebucket-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-samclisourcebucket-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://<restapiid>.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!

Paso 4: ejecutar la aplicación

En este paso, enviará una GET solicitud a su API punto final y verá el resultado de la función Lambda.

Para obtener el valor de su API punto final

A partir de la información que muestra la CLI de AWS SAM en el paso anterior, localice la sección Outputs. En esta sección, localice su HelloWorldApi recurso para encontrar el valor de su HTTP punto final. El siguiente es un ejemplo de salida:

----------------------------------------------------------------------------------------------------------------------------------------------
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/
...
----------------------------------------------------------------------------------------------------------------------------------------------

También puede utilizar el comando sam list endpoints --output json para obtener esta información. El siguiente es un ejemplo de salida:


$ 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 su función

Con su navegador o la línea de comandos, envíe una GET solicitud a su API punto final. 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, utilice la CLI de AWS SAM para invocar la función de Lambda en la Nube de AWS.

Para invocar una función de Lambda en la nube

Tome nota del LogicalResourceId de la función del paso anterior. Debería ser HelloWorldFunction.
En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam remote invoke HelloWorldFunction --stack-name sam-app
```

AWS SAMCLIInvoca tu función en la nube y devuelve una respuesta. El siguiente es un ejemplo de salida:


$ 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: Modifica y sincroniza tu 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

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam sync --watch
```

La CLI de AWS SAM 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 CLI de AWS SAM realiza una implementación inicial antes de comenzar a monitorear los cambios locales. El siguiente es un ejemplo de salida:


$ 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 <YOUR 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-samclisourcebucket-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 su función de Lambda. AWS SAMCLIDetectará automáticamente este cambio y sincronizará la aplicación con el Nube de AWS.

Para modificar y sincronizar su aplicación

Abre IDE el sam-app/hello_world/app.py archivo que elijas.

Cambie el message y guarde 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!",
            ...
        }),
    }

AWS SAMCLIDetecta el cambio y sincroniza la aplicación con el Nube de AWS. El siguiente es un ejemplo de salida:

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.

Para verificar el cambio, vuelva a enviar una GET solicitud a su API dispositivo de punto final.


$ curl https://ets1gv8lxi.execute-api.us-west-2.amazonaws.com/Prod/hello/
{"message": "hello everyone!"}

Paso 7: (opcional) probar su aplicación localmente

nota

Este paso es opcional, ya que debe disponer de Docker en su equipo local.

importante

Para usar la CLI de AWS SAM para pruebas locales, debe haber instalado y configurado Docker. Para obtener más información, consulte Instalar Docker.

En este paso, se utiliza el AWS SAMCLI sam local comando para probar la aplicación de forma local. Para ello, la CLI de AWS SAM crea un entorno local utilizando Docker. Este entorno local emula el entorno de ejecución basado en la nube de su función de Lambda.

Hará lo siguiente:

Cree un entorno local para su función de Lambda e invoquela.
Aloje el HTTP API punto final de forma local y utilícelo para invocar la función Lambda.

Para invocar una función de Lambda localmente

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam local invoke
```

La CLI de AWS SAM crea un contenedor de Docker local e invoca su función. El siguiente es un ejemplo de salida:


$ 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 su servidor de forma local API

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam local start-api
```

AWS SAMCLICrea un Docker contenedor local para la función Lambda y crea un HTTP servidor local para simular el punto final. API El siguiente es un ejemplo de salida:


$ 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 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

Con su navegador o la línea de comandos, envíe una GET solicitud a su API punto final 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

En su línea de comandos, desde el directorio del proyecto sam-app, ejecute lo siguiente:
```
$ sam delete
```

La CLI de AWS SAM le pedirá que confirme. A continuación, eliminará el bucket y la AWS CloudFormation pila de Amazon S3 de la aplicación. El siguiente es un ejemplo de salida:


$ 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, consulteSolución de problemas para AWS SAM CLI.

Más información

Para seguir informándote AWS SAM, consulta los siguientes recursos:

El taller completo de AWS SAM: un taller diseñado para enseñarle muchas de las principales características que AWS SAM ofrece.
Sesiones con SAM: serie de vídeos sobre su uso AWS SAM creada por nuestro equipo de AWS Serverless Developer Advocate.
Serverless Land: sitio que reúne la información más reciente, blogs, vídeos, códigos y recursos de aprendizaje sobre AWS sin servidor.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Opcional: compruebe la AWS SAM CLI installer (instalador)

¿Cómo usar AWS SAM