Usando infraestrutura generativa como código com o Application Composer

Esta publicação foi escrita por Anna Spysz, engenheira de front-end do AWS Application Composer e adaptado para Português por Daniel ABIB, arquiteto sênior de soluções.

O AWS Application Composer foi lançado no AWS Management Console há um ano e agora foi expandido para o VS Code como parte do AWS Toolkit. Isso inclui acesso a um parceiro generativo de IA que ajuda você a escrever infraestrutura como código (IaC) para todos os mais de 1.100 recursos do AWS CloudFormation aos quais o Application Composer agora oferece suporte.

Visão geral

O Application Composer permite criar modelos de IaC arrastando e soltando cartões (cards) em uma tela virtual. Eles representam os recursos do CloudFormation, que você pode conectar para criar permissões e referências. Com suporte para todos os mais de 1100 recursos que o CloudFormation permite, agora você pode criar com tudo, desde o AWS Amplify até o X-Ray.

Anteriormente, os recursos padrão do CloudFormation vinham somente com uma configuração básica. Adicionar um recurso do Amplify App resultou na seguinte configuração por padrão:

  MyAmplifyApp:
    Type: AWS::Amplify::App
    Properties:
      Name: <String>

E no console:

AWS App Composer no console

Agora, o Application Composer no IDE usa IA generativa para gerar configurações específicas de recursos como validação em relação ao esquema CloudFormation para garantir valores válidos.

Ao trabalhar em um modelo (template) do CloudFormation ou do AWS Serverless Application Model (AWS SAM) no VS Code, você pode fazer login com seu ID do Builder e gerar várias configurações sugeridas no Application Composer. Aqui está um exemplo de uma configuração gerada por IA para o tipo AWS: :Amplify: :App:

Configuração gerada por IA para o tipo de aplicativo Amplify

Essas sugestões são específicas para o tipo de recurso e são protegidas por uma verificação no esquema do CloudFormation para garantir valores válidos ou espaços reservados úteis. Em seguida, você pode selecionar, usar e modificar as sugestões para atender às suas necessidades.

Agora você sabe como gerar um exemplo básico com um recurso, mas vamos ver como criar um aplicativo completo com a ajuda de sugestões geradas pela IA. Este exemplo recria um aplicativo Serverless a partir de um tutorial do Serverless Land, “Use os recursos do GenAI para criar um chatbot”, usando o Application Composer e sugestões de código generativas baseadas em IA.

Comece a usar o AWS Toolkit no VS Code

Se você ainda não tem a extensão do AWS Toolkit, você pode encontrá-la na guia Extensões no VS Code. Instale ou atualize-o pelo menos para a versão 2.1.0, para que a tela mostre o Amazon Q e o Application Composer:

Amazon Q e Application Composer

Em seguida, para habilitar a geração de sugestões de código baseadas em IA, você deve habilitar o Amazon CodeWhisperer usando seu ID de construtor. A maneira mais fácil é abrir o Amazon Q Chat e selecionar Autenticar. Na próxima tela, selecione a opção Builder ID e, em seguida, faça login com seu Builder ID.

Habilite o Amazon CodeWhisperer usando seu Builder ID

Depois de fazer login, sua conexão aparece no painel do kit de ferramentas do VS Code:

Conexão no painel do kit de ferramentas VS Code

Construindo com o Application Composer

Com o kit de ferramentas instalado e conectado ao seu Builder ID, você está pronto para começar a criar.

Em um novo espaço de trabalho, crie uma pasta para o aplicativo e um arquivo template.yaml em branco.
Abra esse arquivo e inicie o Application Composer escolhendo o ícone no canto superior direito.

Diagrama de arquitetura original

O tutorial original inclui este diagrama de arquitetura:

Inicie o Application Composer

Primeiro, adicione os serviços no diagrama para esboçar a arquitetura do aplicativo, que cria simultaneamente um modelo implantável do CloudFormation:

Na lista de componentes aprimorados Enhanced components, arraste uma função Lambda e uma camada Lambda.
Clique duas vezes no recurso Função para editar suas propriedades. Renomeie a ID lógica da função Lambda para LexgenaiBotLambda.
Altere o caminho de origem para src/LexgenaibotLambda e o runtime para Python.
Altere o valor do handler para TextGeneration.lambda_handler e escolha Salvar.
Clique duas vezes no recurso Layer para editar suas propriedades. Renomeie a camada Boto3Layer e altere seu método de construção para Python. Altere seu caminho de origem para src/Boto3PillowPyshorteners.zip.
Por fim, conecte a camada à função para adicionar uma referência entre elas. Sua tela tem a seguinte aparência:

Sua tela do App Composer

O arquivo template.yaml agora está atualizado para incluir esses recursos. No diretório de origem, você pode ver alguns arquivos de função gerados. Você os substituirá pela função tutorial e pelas camadas posteriormente.

Na primeira etapa, você adicionou alguns recursos e o IaC gerou o Application Composer que inclui padrões de melhores práticas. Em seguida, você usará os componentes padrão do CloudFormation.

Usando IA para componentes padrão

Comece usando a barra de pesquisa para pesquisar e adicionar vários dos componentes padrão necessários para seu aplicativo.

Pesquise e adicione componentes padrão

Na barra de pesquisa de recursos, digite “lambda” e adicione o tipo de recurso AWS: :Lambda: :Permissionà tela.
Digite “iam” na barra de pesquisa e adicione o tipo AWS: :IAM: :Policy.
Adicione dois recursos do tipo AWS: :IAM: :Role.

Seu aplicativo agora tem a seguinte aparência:

Tela atualizada

Alguns recursos têm todos os padrões de que você precisa. Por exemplo, ao adicionar o recurso AWS: :Lambda: :Permission, substitua os valores do espaço reservado por:

FunctionName: !Ref LexGenAIBotLambda
Action: lambda:InvokeFunction
Principal: lexv2.amazonaws.com

Outros recursos, como as funções do IAM e a política do IAM, têm uma configuração básica. É aqui que você pode usar o assistente de IA. Selecione um recurso de função do IAM e escolha Generate suggestions para ver o que a IA generativa sugere.

Gere sugestões

Como essas sugestões são geradas por um Large Language Model (LLM), elas podem diferir entre cada geração. Eles são verificados em relação ao esquema do CloudFormation, garantindo a validade e fornecendo uma variedade de configurações para suas necessidades.

A geração de configurações diferentes dá uma ideia de como deve ser a política de um recurso e, geralmente, fornece chaves que você pode preencher com os valores necessários. Use as configurações a seguir para cada recurso, substituindo os valores gerados quando aplicável.

Clique duas vezes no recurso “Permissão” para editar suas configurações. Altere sua ID lógica para LexgenaibotLambdaInvoke e substitua sua configuração de recursos pela seguinte e, em seguida, escolha Salvar:

Action: lambda:InvokeFunction
FunctionName: !GetAtt LexGenAIBotLambda.Arn
Principal: lexv2.amazonaws.com

2. Clique duas vezes no recurso “Função” para editar suas configurações. Altere sua ID lógica para CfnLexGenaideMorole e substitua sua configuração de recursos pela seguinte e, em seguida, escolha Salvar:

AssumeRolePolicyDocument:
  Statement:
    - Action: sts:AssumeRole
      Effect: Allow
      Principal:
        Service: lexv2.amazonaws.com
  Version: '2012-10-17'
ManagedPolicyArns:
  - !Join
    - ''
    - - 'arn:'
      - !Ref AWS::Partition
      - ':iam::aws:policy/AWSLambdaExecute'

3. Clique duas vezes no recurso “Role2” para editar suas configurações. Altere sua ID lógica para LexgenaiBotLambdaServiceRole e substitua sua configuração de recursos pela seguinte e, em seguida, escolha Salvar:

AssumeRolePolicyDocument:
  Statement:
    - Action: sts:AssumeRole
      Effect: Allow
      Principal:
        Service: lambda.amazonaws.com
  Version: '2012-10-17'
ManagedPolicyArns:
  - !Join
    - ''
    - - 'arn:'
      - !Ref AWS::Partition
      - ':iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'

4. Clique duas vezes no recurso “Política” para editar suas configurações. Altere sua ID lógica para LexgenaiBotLambdaServiceRoleDefaultPolicy e substitua sua configuração de recursos pela seguinte, depois escolha Salvar:

PolicyDocument:
  Statement:
    - Action:
        - lex:*
        - logs:*
        - s3:DeleteObject
        - s3:GetObject
        - s3:ListBucket
        - s3:PutObject
      Effect: Allow
      Resource: '*'
    - Action: bedrock:InvokeModel
      Effect: Allow
      Resource: !Join
        - ''
        - - 'arn:aws:bedrock:'
          - !Ref AWS::Region
          - '::foundation-model/anthropic.claude-v2'
  Version: '2012-10-17'
PolicyName: LexGenAIBotLambdaServiceRoleDefaultPolicy
Roles:
  - !Ref LexGenAIBotLambdaServiceRole

Depois de atualizar as propriedades de cada recurso, você verá as conexões e os agrupamentos feitos automaticamente entre eles:

Conexões e agrupamentos automáticos

Para adicionar o bot Amazon Lex:

No seletor de recursos, pesquise e adicione o tipo AWS::Lex::Bot. Aqui está outra chance de ver qual configuração a IA sugere.
Altere o ID lógico do bot Amazon Lex para LexgenaiBot e atualize sua configuração para o seguinte:

DataPrivacy:
  ChildDirected: false
IdleSessionTTLInSeconds: 300
Name: LexGenAIBot
RoleArn: !GetAtt CfnLexGenAIDemoRole.Arn
AutoBuildBotLocales: true
BotLocales:
  - Intents:
      - InitialResponseSetting:
          CodeHook:
            EnableCodeHookInvocation: true
            IsActive: true
            PostCodeHookSpecification: {}
        IntentClosingSetting:
          ClosingResponse:
            MessageGroupsList:
              - Message:
                  PlainTextMessage:
                    Value: Hi there, I'm a GenAI Bot. How can I help you?
        Name: WelcomeIntent
        SampleUtterances:
          - Utterance: Hi
          - Utterance: Hey there
          - Utterance: Hello
          - Utterance: I need some help
          - Utterance: Help needed
          - Utterance: Can I get some help?
      - FulfillmentCodeHook:
          Enabled: true
          IsActive: true
          PostFulfillmentStatusSpecification: {}
        InitialResponseSetting:
          CodeHook:
            EnableCodeHookInvocation: true
            IsActive: true
            PostCodeHookSpecification: {}
        Name: GenerateTextIntent
        SampleUtterances:
          - Utterance: Generate content for
          - Utterance: 'Create text '
          - Utterance: 'Create a response for '
          - Utterance: Text to be generated for
      - FulfillmentCodeHook:
          Enabled: true
          IsActive: true
          PostFulfillmentStatusSpecification: {}
        InitialResponseSetting:
          CodeHook:
            EnableCodeHookInvocation: true
            IsActive: true
            PostCodeHookSpecification: {}
        Name: FallbackIntent
        ParentIntentSignature: AMAZON.FallbackIntent
    LocaleId: en_US
    NluConfidenceThreshold: 0.4
Description: Bot created demonstration of GenAI capabilities.
TestBotAliasSettings:
  BotAliasLocaleSettings:
    - BotAliasLocaleSetting:
        CodeHookSpecification:
          LambdaCodeHook:
            CodeHookInterfaceVersion: '1.0'
            LambdaArn: !GetAtt LexGenAIBotLambda.Arn
        Enabled: true
      LocaleId: en_US

Escolha Salvar no recurso.

Depois que todos os seus recursos estiverem configurados, seu aplicativo terá a seguinte aparência:

Nova tela gerada por IA

Adicionando código de função e implantação

Depois que sua arquitetura estiver definida, revise e refine seu arquivo template.yaml. Para obter uma referência detalhada e garantir que todos os seus valores estejam corretos, visite o repositório do GitHub e verifique o arquivo template.yaml.

Copie o Lambda layer diretamente do repositório e adicione-a ao. /src/Boto3PillowPyshorteners.zip.
No diretório .src/, renomeie o handler.py gerado para TextGeneration.py. Você também pode excluir arquivos desnecessários.
Abra o TextGeneration.py e substitua o código do espaço reservado pelo seguinte:

import json
import boto3
import os
import logging
from botocore.exceptions import ClientError

LOG = logging.getLogger()
LOG.setLevel(logging.INFO)

region_name = os.getenv("region", "us-east-1")
s3_bucket = os.getenv("bucket")
model_id = os.getenv("model_id", "anthropic.claude-v2")

# Bedrock client used to interact with APIs around models
bedrock = boto3.client(service_name="bedrock", region_name=region_name)

# Bedrock Runtime client used to invoke and question the models
bedrock_runtime = boto3.client(service_name="bedrock-runtime", region_name=region_name)


def get_session_attributes(intent_request):
    session_state = intent_request["sessionState"]
    if "sessionAttributes" in session_state:
        return session_state["sessionAttributes"]

    return {}

def close(intent_request, session_attributes, fulfillment_state, message):
    intent_request["sessionState"]["intent"]["state"] = fulfillment_state
    return {
        "sessionState": {
            "sessionAttributes": session_attributes,
            "dialogAction": {"type": "Close"},
            "intent": intent_request["sessionState"]["intent"],
        },
        "messages": [message],
        "sessionId": intent_request["sessionId"],
        "requestAttributes": intent_request["requestAttributes"]
        if "requestAttributes" in intent_request
        else None,
    }

def lambda_handler(event, context):
    LOG.info(f"Event is {event}")
    accept = "application/json"
    content_type = "application/json"
    prompt = event["inputTranscript"]

    try:
        request = json.dumps(
            {
                "prompt": "\n\nHuman:" + prompt + "\n\nAssistant:",
                "max_tokens_to_sample": 4096,
                "temperature": 0.5,
                "top_k": 250,
                "top_p": 1,
                "stop_sequences": ["\\n\\nHuman:"],
            }
        )

        response = bedrock_runtime.invoke_model(
            body=request,
            modelId=model_id,
            accept=accept,
            contentType=content_type,
        )

        response_body = json.loads(response.get("body").read())
        LOG.info(f"Response body: {response_body}")
        response_message = {
            "contentType": "PlainText",
            "content": response_body["completion"],
        }
        session_attributes = get_session_attributes(event)
        fulfillment_state = "Fulfilled"

        return close(event, session_attributes, fulfillment_state, response_message)

    except ClientError as e:
        LOG.error(f"Exception raised while execution and the error is {e}")

4. Para implantar a infraestrutura, volte para a extensão App Composer e escolha o ícone Sincronizar. Siga as instruções guiadas do AWS SAM para concluir a implantação.

Sincronização do App Composer

Depois que a mensagem SAM Sync for bem-sucedida, navegue até o CloudFormation no AWS Management Console para ver os recursos recém-criados. Para continuar criando o chatbot, siga o restante do tutorial original.

Conclusão

Este guia demonstra como o CloudFormation gerado por IA pode simplificar seu fluxo de trabalho no Application Composer, aprimorar sua compreensão das configurações de recursos e acelerar o processo de desenvolvimento. Como sempre, siga a Política de IA Responsável da AWS ao usar esses recursos.

Este blog foi traduzido para Português e o blog original se encontra neste link.

Sobre a Autora

Anna Spysz é engenheira de front-end do AWS Application Composer

Biografia do tradutor

Daniel Abib é arquiteto de soluções sênior na AWS, com mais de 25 anos trabalhando com gerenciamento de projetos, arquiteturas de soluções escaláveis, desenvolvimento de sistemas e CI/CD, microsserviços, arquitetura Serverless & Containers e segurança. Ele trabalha apoiando clientes corporativos, ajudando-os em sua jornada para a nuvem.

https://www.linkedin.com/in/danielabib/

O blog da AWS