Usar o Lambda com a infraestrutura como código (IaC) - AWS Lambda
Ferramentas de IaC para o LambdaConceitos básicos de IaC para o LambdaPróximas etapasRegiões com suporte para integração do Lambda com o Application Composer

Usar o Lambda com a infraestrutura como código (IaC)

O Lambda oferece várias maneiras de implantar códigos e criar funções. Por exemplo, você pode usar o console do Lambda ou a AWS Command Line Interface (AWS CLI) para criar ou atualizar manualmente as funções do Lambda. Além dessas opções manuais, a AWS oferece várias soluções para implantar funções do Lambda e aplicações sem servidor usando a infraestrutura como código (IaC). Com a IaC, você pode provisionar e manter funções do Lambda e outros recursos da AWS usando código, em vez de processos e configurações manuais.

Na maioria das vezes, as funções do Lambda não são executadas isoladamente. Em vez disso, elas fazem parte de uma aplicação sem servidor com outros recursos, como bancos de dados, filas e armazenamento. Com a IaC, você pode automatizar os processos de implantação para implantar e atualizar de forma rápida e repetitiva aplicações inteiras sem servidor associadas a vários recursos da AWS separados. Essa abordagem agiliza o ciclo de desenvolvimento, torna o gerenciamento de configurações mais fácil e garante que seus recursos sejam implantados sempre da mesma forma.

Ferramentas de IaC para o Lambda

Para implantar funções do Lambda e aplicações sem servidor usando a IaC, a AWS oferece várias outras ferramentas e serviços.

O AWS CloudFormation foi o primeiro serviço oferecido pela AWS para criar e configurar recursos de nuvem. Com o AWS CloudFormation, você cria modelos de texto para definir infraestruturas e códigos. Com a introdução de novos serviços pela AWS e o aumento da complexidade da criação de modelos para o AWS CloudFormation, outras duas ferramentas foram lançadas. O AWS SAM é outra estrutura baseada em modelos para definir aplicações sem servidor. O AWS Cloud Development Kit (AWS CDK) é uma abordagem que prioriza o código para definir e provisionar a infraestrutura usando estruturas de código em várias linguagens de programação populares.

Tanto com o AWS SAM quanto com o AWS CDK, o AWS CloudFormation opera em segundo plano para criar e implantar sua infraestrutura. O diagrama a seguir ilustra a relação entre essas ferramentas, e os parágrafos abaixo do diagrama explicam suas principais características.

Diagrama mostrando como o AWS SAM e o AWS CDK implantam códigos e recursos da AWS usando o AWS CloudFormation, que cria a pilha de aplicações.

  • AWS CloudFormation- Com CloudFormation você modela e configura seus AWS recursos usando um modelo YAML ou JSON que descreve seus recursos e suas propriedades. CloudFormation provisiona seus recursos de forma segura e repetível, permitindo que você construa com frequência sua infraestrutura e aplicativos sem etapas manuais. Quando você altera a configuração, CloudFormation determina as operações corretas a serem executadas para atualizar sua pilha. CloudFormation pode até mesmo reverter as alterações.

  • AWS Serverless Application Model (AWS SAM): o AWS SAM é uma estrutura de código aberto para a definição de aplicações sem servidor. Os modelos do AWS SAM usam uma sintaxe abreviada para definir funções, APIs, bancos de dados e mapeamentos da origem do evento com apenas algumas linhas de texto (YAML) por recurso. Durante a implantação, o AWS SAM transforma e expande a sintaxe do AWS SAM em sintaxe do AWS CloudFormation. Por esse motivo, qualquer CloudFormation sintaxe pode ser adicionada aos AWS SAM modelos. Isso oferece AWS SAM todo o poder do CloudFormation, mas com menos linhas de configuração.

  • AWS Cloud Development Kit (AWS CDK)- Com oAWS CDK, você define sua infraestrutura usando construções de código e a provisiona por meio AWS CloudFormation dela. AWS CDKpermite modelar a infraestrutura de aplicativos com Python TypeScript, Java, .NET e Go (no Developer Preview) usando seu IDE, ferramentas de teste e padrões de fluxo de trabalho existentes. Você tem acesso a todos os benefícios do AWS CloudFormation, incluindo implantação repetível, fácil reversão e detecção de desvios.

A AWS também fornece um serviço denominado AWS Application Composer para desenvolver modelos de IaC usando uma interface gráfica simples. Com o Application Composer, você projeta uma arquitetura de aplicações arrastando, agrupando e conectando os Serviços da AWS em uma tela visual. Em seguida, o Application Composer cria um modelo do AWS SAM ou do AWS CloudFormation com base no seu design que você pode usar para implantar aplicações.

Na seção Conceitos básicos de IaC para o Lambda abaixo, o Application Composer é usado para desenvolver um modelo para uma aplicação sem servidor baseada em uma função do Lambda existente.

Conceitos básicos de IaC para o Lambda

Neste tutorial, você pode começar a usar a IaC com o Lambda elaborando um modelo do AWS SAM com base em uma função do Lambda existente e, em seguida, criando uma aplicação sem servidor no Application Composer adicionando outros recursos da AWS.

Se preferir começar com um tutorial do AWS CloudFormation ou do AWS SAM para aprender a trabalhar com modelos sem usar o Application Composer, você encontrará links para outros recursos na seção Próximas etapas no final desta página.

Ao realizar este tutorial, você aprenderá alguns conceitos fundamentais, como a forma que os recursos da AWS são especificados no AWS SAM. Você também aprenderá a usar o Application Composer para criar uma aplicação sem servidor que você pode implantar usando o AWS SAM ou o AWS CloudFormation.

Para concluir o tutorial, você executará as seguintes tarefas:

  • Criar exemplo de função do Lambda

  • Usar o console do Lambda para visualizar o modelo do AWS SAM para a função

  • Exportar a configuração da função para o AWS Application Composer e criar uma aplicação simples sem servidor com base na configuração da função

  • Salvar um modelo do AWS SAM atualizado que você possa usar como base para implantar sua aplicação sem servidor

Na seção Próximas etapas, você encontrará recursos que podem ser usados para aprender mais sobre o AWS SAM e o Application Composer. Esses recursos incluem links para tutoriais mais avançados que ensinam como implantar uma aplicação sem servidor usando o AWS SAM.

Pré-requisitos

Neste tutorial, o recurso de sincronização local do Application Composer é usado para salvar os arquivos de modelo e código na sua máquina de compilação local. Para usar esse recurso, você precisa de um navegador compatível com a API File System Access, que permite a uma aplicação da Web ler, gravar e salvar arquivos no sistema de arquivos local. Recomendamos usar o Google Chrome ou o Microsoft Edge. Para obter mais informações sobre a API File System Access, consulte What is the File System Access API?

Criar uma função do Lambda

Nessa primeira etapa, você criará uma função do Lambda que poderá ser usada para concluir o restante do tutorial. Para simplificar, use o console do Lambda para criar uma função básica “Hello world” com o runtime do Python 3.11.

Para criar uma função do Lambda “Hello world” com o console:

  1. Abra o console do lambda.

  2. Escolha a opção Criar função.

  3. Deixe a opção Criar do zero selecionada e, em Informações básicas, insira LambdaIaCDemo em Nome da função.

  4. Em Runtime, escolha Python 3.11.

  5. Escolha a opção Criar função.

Ver o modelo do AWS SAM da sua função

Antes de exportar a configuração da função para o Application Composer, use o console do Lambda para ver a configuração atual da função como um modelo do AWS SAM. Seguindo as etapas desta seção, você aprenderá sobre a anatomia de um modelo do AWS SAM e como definir recursos, como funções do Lambda, para começar a especificar uma aplicação sem servidor.

Ver o modelo do AWS SAM da função

  1. Abra a página Funções do console do Lambda.

  2. Escolha a função que você acabou de criar (LambdaIaCDemo).

  3. No painel Visão geral da função, escolha Modelo.

    No lugar do diagrama que representa a configuração da sua função, você verá um modelo do AWS SAM para sua função. O modelo será algo assim:

    # This AWS SAM template has been generated from your function's 
# configuration. If your function has one or more triggers, note 
# that the AWS resources associated with these triggers aren't fully 
# specified in this template and include placeholder values.Open this template 
# in AWS Application Composer or your favorite IDE and modify 
# it to specify a serverless application with other AWS resources. 
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
  LambdaIaCDemo:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Description: ''
      MemorySize: 128
      Timeout: 3
      Handler: lambda_function.lambda_handler
      Runtime: python3.11
      Architectures:
        - x86_64
      EventInvokeConfig:
        MaximumEventAgeInSeconds: 21600
        MaximumRetryAttempts: 2
      EphemeralStorage:
        Size: 512
      RuntimeManagementConfig:
        UpdateRuntimeOn: Auto
      SnapStart:
        ApplyOn: None
      PackageType: Zip
      Policies:
        Statement:
          - Effect: Allow
            Action:
              - logs:CreateLogGroup
            Resource: arn:aws:logs:us-east-1:123456789012:*
          - Effect: Allow
            Action:
              - logs:CreateLogStream
              - logs:PutLogEvents
            Resource:
              - >-
                arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/LambdaIaCDemo:*

Vamos analisar o modelo YAML da sua função e entender alguns conceitos-chave.

O modelo começa com a declaração Transform: AWS::Serverless-2016-10-31. Ela é necessária porque os modelos do AWS SAM são implantados em segundo plano por meio do AWS CloudFormation. A declaração Transform identifica o modelo como um arquivo de modelo do AWS SAM.

Após a declaração Transform, temos a seção Resources. Nela, são definidos os recursos da AWS que você deseja implantar com o modelo do AWS SAM. Os modelos do AWS SAM podem conter uma combinação de recursos do AWS SAM e do AWS CloudFormation. Isso ocorre porque, durante a implantação, os modelos do AWS SAM se expandem para modelos do AWS CloudFormation; portanto, qualquer sintaxe válida do AWS CloudFormation pode ser adicionada a um modelo do AWS SAM.

No momento, só há um recurso definido na seção Resources do modelo, sua função do Lambda LambdaIaCDemo. Para adicionar uma função do Lambda a um modelo do AWS SAM, use o tipo de recurso AWS::Serverless::Function. O recurso Properties de uma função do Lambda define o runtime da função, o manipulador da função e outras opções de configuração. O caminho para o código-fonte da função que o AWS SAM deve usar para implantar a função também é definido aqui. Para saber mais sobre os recursos da função Lambda emAWS SAM, consulte o AWS::Serverless::FunctionGuia do AWS SAMdesenvolvedor.

Além das propriedades e configurações da função, o modelo também especifica uma política do AWS Identity and Access Management (IAM) para a função. Essa política dá permissão à sua função para gravar registros no Amazon CloudWatch Logs. Quando você cria uma função no console do Lambda, ele anexa automaticamente essa política à sua função. Para saber mais sobre como especificar uma política do IAM para uma função em um AWS SAM modelo, consulte a policies propriedade na AWS::Serverless::Functionpágina do Guia do AWS SAM desenvolvedor.

Para saber mais sobre a estrutura de modelos do AWS SAM, consulte AWS SAM template anatomy.

Usar o AWS Application Composer para criar uma aplicação sem servidor

Para começar a criar uma aplicação simples sem servidor usando o modelo do AWS SAM da função como ponto de partida, exporte a configuração da função para o Application Composer e ative o modo de sincronização local dele. A sincronização local salva automaticamente o código da função e o modelo do AWS SAM na máquina de compilação local e mantém o modelo salvo sincronizado à medida que você adiciona outros recursos da AWS no Application Composer.

Exportar a função para o Application Composer

  1. No painel Visão geral da função, escolha Exportar para o Application Composer.

    Para exportar a configuração e o código da função para o Application Composer, o Lambda cria um bucket do Amazon S3 na sua conta para armazenar esses dados temporariamente.

  2. Na caixa de diálogo, escolha Confirmar e criar projeto para aceitar o nome padrão desse bucket e exportar a configuração e o código da função para o Application Composer.

  3. (Opcional) Para escolher outro nome para o bucket do Amazon S3 criado pelo Lambda, insira um novo nome e escolha Confirmar e criar projeto. Os nomes de buckets do Amazon S3 devem ser exclusivos no mundo todo e seguir as regras de nomenclatura de buckets.

    Ao selecionar Confirmar e criar projeto, o console do Application Composer é aberto. Na tela, você verá sua função do Lambda.

  4. No Menu suspenso, escolha Ativar sincronização local.

  5. Na caixa de diálogo exibida, escolha Selecionar pasta e selecione uma pasta na sua máquina de compilação local.

  6. Escolha Ativar para ativar a sincronização local.

Para exportar a função para o Application Composer, você precisa de permissão para usar determinadas ações de API. Se não conseguir exportar sua função, consulte Permissões obrigatórias e verifique se você tem as permissões necessárias.

nota

O preço padrão do Amazon S3 se aplica ao bucket criado pelo Lambda quando você exporta uma função para o Application Composer. Os objetos que o Lambda coloca no bucket são excluídos automaticamente após dez dias, mas o Lambda não exclui o bucket em si.

Para evitar que cobranças adicionais sejam adicionadas à sua Conta da AWS, siga as instruções em Excluir um bucket depois de exportar a função para o Application Composer. Para obter mais informações sobre o bucket do Amazon S3 criado pelo Lambda, consulte Usar o AWS Lambda com o AWS Application Composer.

Projetar a aplicação sem servidor no Application Composer

Depois de ativar a sincronização local, as alterações feitas no Application Composer serão refletidas no modelo do AWS SAM salvo na sua máquina de compilação local. Agora você pode arrastar e soltar recursos adicionais da AWS na tela do Application Composer para criar sua aplicação. Neste exemplo, você adiciona uma fila simples do Amazon SQS como gatilho para sua função do Lambda e uma tabela do DynamoDB na qual a função gravará os dados.

  1. Para adicionar um gatilho do Amazon SQS à função do Lambda, faça o seguinte:

    1. No campo de pesquisa na paleta Recursos, insira SQS.

    2. Arraste o recurso Fila do SQS para sua tela e posicione-o à esquerda da função do Lambda.

    3. Escolha Detalhes e, em ID lógico, insira LambdaIaCQueue.

    4. Escolha Salvar.

    5. Conecte seus recursos do Amazon SQS e do Lambda clicando na porta Assinatura no cartão de fila do SQS e arrastando-a para a porta à esquerda no cartão da função do Lambda. Se aparecer uma linha entre os dois recursos, é sinal de que a conexão teve êxito. O Application Composer também exibe uma mensagem na parte inferior da tela indicando que os dois recursos foram conectados com êxito.

  2. Para adicionar uma tabela do Amazon DynamoDB na qual a função do Lambda gravará os dados, faça o seguinte:

    1. No campo de pesquisa na paleta Recursos, insira DynamoDB.

    2. Arraste o recurso Tabela do DynamoDB para sua tela e posicione-o à direita da função do Lambda.

    3. Escolha Detalhes e, em ID lógico, insira LambdaIaCTable.

    4. Escolha Salvar.

    5. Conecte a tabela do DynamoDB à sua função do Lambda clicando na porta à direita do cartão da função do Lambda e arrastando-a até a porta à esquerda do cartão do DynamoDB.

Agora que esses recursos extras foram adicionados, vamos dar uma olhada no modelo do AWS SAM atualizado que foi criado pelo Application Composer.

Ver o modelo do AWS SAM atualizado

  • Na tela do Application Composer, escolha Modelo para alternar da visualização da tela para a visualização do modelo.

Agora, seu modelo do AWS SAM deve conter os seguintes recursos e propriedades adicionais:

  • Uma fila do Amazon SQS com o identificador LambdaIaCQueue

    LambdaIaCQueue:
    Type: AWS::SQS::Queue
    Properties:
      MessageRetentionPeriod: 345600

    Quando você adiciona uma fila do Amazon SQS usando o Application Composer, ele define a propriedade MessageRetentionPeriod. Você também pode definir a propriedade FifoQueue selecionando Detalhes no cartão da fila do SQS e marcando ou desmarcando Fila FIFO.

    Para definir outras propriedades para sua fila, você pode adicioná-las manualmente ao modelo. Para saber mais sobre o recurso AWS::SQS::Queue e suas propriedades disponíveis, consulte AWS::SQS::Queue no Guia do usuário do AWS CloudFormation.

  • Uma propriedade Events na definição da função do Lambda que especifica a fila do Amazon SQS usada como gatilho para a função.

    Events:
  LambdaIaCQueue:
    Type: SQS
    Properties:
      Queue: !GetAtt LambdaIaCQueue.Arn
      BatchSize: 1

    A propriedade Events consiste em um tipo de evento e um conjunto de propriedades que dependem desse tipo. Para saber mais sobre as diferentes configurações Serviços da AWS que você pode configurar para acionar uma função Lambda e as propriedades que você pode definir, consulte o EventSourceGuia do AWS SAMdesenvolvedor.

  • Uma tabela do DynamoDB com o identificador LambdaIaCTable

    LambdaIaCTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      StreamSpecification:
        StreamViewType: NEW_AND_OLD_IMAGES

    Ao adicionar uma tabela do DynamoDB usando o Application Composer, você pode definir as chaves da tabela escolhendo Detalhes no cartão da tabela do DynamoDB e editando os valores das chaves. O Application Composer também define valores padrão para várias outras propriedades, incluindo BillingMode e StreamViewType.

    Para saber mais sobre essas propriedades e outras que você pode adicionar ao modelo do AWS SAM, consulte AWS::DynamoDB::Table no Guia do usuário do AWS CloudFormation.

  • Uma nova política do IAM que dá permissão à sua função para realizar operações CRUD na tabela do DynamoDB que você adicionou.

    Policies:
...
  - DynamoDBCrudPolicy:
    TableName: !Ref LambdaIaCTable

O modelo completo do AWS SAM resultante será algo assim:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Specification template describing your function.
Resources:
  LambdaIaCDemo:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Description: ''
      MemorySize: 128
      Timeout: 3
      Handler: lambda_function.lambda_handler
      Runtime: python3.11
      Architectures:
        - x86_64
      EventInvokeConfig:
        MaximumEventAgeInSeconds: 21600
        MaximumRetryAttempts: 2
      EphemeralStorage:
        Size: 512
      RuntimeManagementConfig:
        UpdateRuntimeOn: Auto
      SnapStart:
        ApplyOn: None
      PackageType: Zip
      Policies:
        - Statement:
            - Effect: Allow
              Action:
                - logs:CreateLogGroup
              Resource: arn:aws:logs:us-east-1:594035263019:*
            - Effect: Allow
              Action:
                - logs:CreateLogStream
                - logs:PutLogEvents
              Resource:
                - arn:aws:logs:us-east-1:594035263019:log-group:/aws/lambda/LambdaIaCDemo:*
        - DynamoDBCrudPolicy:
            TableName: !Ref LambdaIaCTable
      Events:
        LambdaIaCQueue:
          Type: SQS
          Properties:
            Queue: !GetAtt LambdaIaCQueue.Arn
            BatchSize: 1
      Environment:
        Variables:
          LAMBDAIACTABLE_TABLE_NAME: !Ref LambdaIaCTable
          LAMBDAIACTABLE_TABLE_ARN: !GetAtt LambdaIaCTable.Arn
  LambdaIaCQueue:
    Type: AWS::SQS::Queue
    Properties:
      MessageRetentionPeriod: 345600
  LambdaIaCTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      StreamSpecification:
        StreamViewType: NEW_AND_OLD_IMAGES

Implantar a aplicação sem servidor usando o AWS SAM (opcional)

Se você quiser usar o AWS SAM para implantar uma aplicação sem servidor usando o modelo que acabou de criar no Application Composer, é necessário primeiro instalar a CLI do AWS SAM. Para isso, siga as instruções em Installing the AWS SAM CLI.

Antes de implantar a aplicação, você também precisa atualizar o código da função que o Application Composer salvou junto com o modelo. No momento, o arquivo lambda_function.py que o Application Composer salvou contém somente o código básico “Hello world” que o Lambda forneceu quando você criou a função.

Para atualizar o código da função, copie o código a seguir e cole-o no arquivo lambda_function.py que o Application Composer salvou na máquina de compilação local. Você especificou o diretório no qual o Application Composer deve salvar esse arquivo quando ativou o modo de sincronização local.

Esse código aceita um par de valores-chave em uma mensagem da fila do Amazon SQS que você criou no Application Composer. Se a chave e o valor forem strings, o código as usará para gravar um item na tabela do DynamoDB definida no modelo.

import boto3
import os
import json

# define the DynamoDB table that Lambda will connect to
tablename = os.environ['LAMBDAIACTABLE_TABLE_NAME']

# create the DynamoDB resource
dynamo = boto3.client('dynamodb')

def lambda_handler(event, context):
    # get the message out of the SQS event
    message = event['Records'][0]['body']
    data = json.loads(message)
    # write event data to DDB table
    if check_message_format(data):
        key = next(iter(data))
        value = data[key]
        dynamo.put_item(
            TableName=tablename,
            Item={
                'id': {'S': key},
                'Value': {'S': value}
            }
        )
    else:
        raise ValueError("Input data not in the correct format")

# check that the event object contains a single key value  
# pair that can be written to the database
def check_message_format(message):
    if len(message) != 1:
        return False
        
    key, value = next(iter(message.items()))
    
    if not (isinstance(key, str) and isinstance(value, str)):
        return False

    else:
        return True
Implantar a aplicação sem servidor

Para implantar sua aplicação usando a CLI do AWS SAM, execute as etapas a seguir. Para que sua função seja compilada e implantada corretamente, a versão 3.11 do Python deve estar instalada na máquina de compilação e no PATH.

  1. Execute o comando a seguir pelo diretório no qual o Application Composer salvou os arquivos template.yaml e lambda_function.py.

    sam build

    Esse comando reúne os artefatos de compilação da aplicação e os coloca no formato e no local adequados para implantá-los.

  2. Para implantar a aplicação e criar os recursos do Lambda, do Amazon SQS e do DynamoDB especificados no modelo do AWS SAM, execute o comando a seguir.

    sam deploy --guided

    Usar o sinalizador --guided significa que o AWS SAM mostrará instruções para guiar você no processo de implantação. Para a implantação, aceite as opções padrão pressionando Enter.

Durante o processo de implantação, o AWS SAM cria os seguintes recursos na sua Conta da AWS:

  • Uma pilha do AWS CloudFormation chamada sam-app

  • Uma função do Lambda com o formato de nome sam-app-LambdaIaCDemo-99VXPpYQVv1M

  • Uma fila do Amazon SQS com o formato do nome sam-app-LambdaIaCQueue-xL87VeKsGiIo

  • Uma tabela do DynamoDB com o formato do nome sam-app-LambdaIaCTable-CN0S66C0VLNV

O AWS SAM também cria as funções e as políticas do IAM necessárias para que a função do Lambda possa ler mensagens da fila do Amazon SQS e realizar operações CRUD na tabela do DynamoDB.

Para saber mais sobre como usar o AWS SAM para implantar aplicações sem servidor, consulte os recursos na seção Próximas etapas.

Testar a aplicação implantada (opcional)

Para confirmar que a aplicação sem servidor foi implantada corretamente, envie uma mensagem para a fila do Amazon SQS que contenha um par de valores-chave e verifique se o Lambda grava um item na tabela do DynamoDB usando esses valores.

Testar a aplicação sem servidor

  1. Abra a página Filas do console do Amazon SQS e selecione a fila que o AWS SAM criou com base no modelo. O nome tem o formato sam-app-LambdaIaCQueue-xL87VeKsGiIo.

  2. Selecione Enviar e receber mensagens e cole o JSON a seguir no Corpo da mensagem na seção Enviar mensagem.

    {
    "myKey": "myValue"
}

  3. Escolha Send Message (Enviar mensagem).

    Enviar a mensagem para a fila fará com que o Lambda invoque sua função por meio do mapeamento da origem do evento definido no modelo do AWS SAM. Para confirmar que o Lambda invocou sua função conforme o esperado, verifique se um item foi adicionado à tabela do DynamoDB.

  4. Abra a página Tabelas do console do DynamoDB e selecione sua tabela. O nome tem o formato sam-app-LambdaIaCTable-CN0S66C0VLNV.

  5. Escolha Explore table items (Explorar itens da tabela). No painel Itens retornados, você verá um item com o id myKey e o Valor myValue.

Próximas etapas

Para saber mais sobre como usar o Application Composer com o AWS SAM e o AWS CloudFormation, comece conferindo Using Application Composer with AWS CloudFormation and AWS SAM.

Para ver um tutorial guiado que usa o AWS SAM para implantar uma aplicação sem servidor projetada no Application Composer, também recomendamos que você realize o tutorial do AWS Application Composer em AWS Serverless Patterns Workshop.

O AWS SAM tem uma interface de linha de comando (CLI) que você pode usar com modelos do AWS SAM e integrações de terceiros compatíveis para criar e executar aplicações sem servidor. Com a CLI do AWS SAM, você pode criar e implantar a aplicação, realizar testes e depuração no local, configurar pipelines de CI/CD e muito mais. Para saber mais sobre como usar a CLI do AWS SAM, consulte Getting started with AWS SAM no Guia do desenvolvedor do AWS Serverless Application Model.

Para saber como implantar uma aplicação sem servidor com um modelo do AWS SAM usando o console do AWS CloudFormation, confira primeiro Usar o console do AWS CloudFormation no Guia do usuário do AWS CloudFormation.

Regiões com suporte para integração do Lambda com o Application Composer

As seguintes Regiões da AWS têm suporte para a integração do Lambda com o Application Composer:

  • Leste dos EUA (Norte da Virgínia)

  • Leste dos EUA (Ohio)

  • Oeste dos EUA (N. da Califórnia)

  • Oeste dos EUA (Oregon)

  • África (Cidade do Cabo)

  • Ásia-Pacífico (Hong Kong)

  • Ásia-Pacífico (Hyderabad)

  • Ásia-Pacífico (Jacarta)

  • Ásia-Pacífico (Melbourne)

  • Ásia-Pacífico (Mumbai)

  • Ásia-Pacífico (Osaka)

  • Ásia-Pacífico (Seul)

  • Ásia-Pacífico (Singapura)

  • Ásia-Pacífico (Sydney)

  • Ásia-Pacífico (Tóquio)

  • Canadá (Central)

  • Europa (Frankfurt)

  • Europa (Zurique)

  • Europa (Irlanda)

  • Europe (London)

  • Europa (Estocolmo)

  • Oriente Médio (Emirados Árabes Unidos)