Gerencie seu bot do Amazon Lex por meio de modelos do AWS CloudFormation | Amazon Web Services

Gerencie seu bot do Amazon Lex por meio de modelos do AWS CloudFormation | Amazon Web Services

Carimbo de data / hora: 16 de abril de 2024 12h11

Amazon-Lex é um serviço de inteligência artificial (IA) totalmente gerenciado com modelos avançados de linguagem natural para projetar, construir, testar e implantar interfaces de conversação em aplicativos. Ele emprega tecnologias avançadas de aprendizagem profunda para entender a entrada do usuário, permitindo que os desenvolvedores criem chatbots, assistentes virtuais e outros aplicativos que podem interagir com os usuários em linguagem natural.

Gerenciar bots do Amazon Lex usando Formação da Nuvem AWS permite criar modelos que definem o bot e todos os recursos da AWS dos quais ele depende. O AWS CloudFormation fornece e configura esses recursos em seu nome, eliminando o risco de erro humano ao implantar bots em novos ambientes. Os benefícios de usar CloudFormation incluem:

  • Consistência – Um modelo do CloudFormation fornece uma maneira mais consistente e automatizada de implantar e gerenciar os recursos associados a um bot do Amazon Lex.
  • Controle de versão – Com o AWS CloudFormation, você pode usar sistemas de controle de versão como o Git para gerenciar seus modelos do CloudFormation. Isso permite que você mantenha diferentes versões do seu bot e reverta para versões anteriores, se necessário.
  • Reutilização – Você pode reutilizar modelos do CloudFormation em vários ambientes, como desenvolvimento, preparação e produção. Isso economiza tempo e esforço na definição do mesmo bot em ambientes diferentes.
  • Expansibilidade – À medida que seu bot do Amazon Lex cresce em complexidade, gerenciá-lo por meio do Console de gerenciamento da AWS torna-se mais desafiador. O AWS CloudFormation permite uma abordagem mais simplificada e eficiente para gerenciar a definição e os recursos do bot.
  • Automação – Usar um modelo CloudFormation permite automatizar o processo de implantação. Você pode usar serviços AWS como AWS Code Pipeline e AWS CodeBuild para criar, testar e implantar seu bot do Amazon Lex automaticamente.

Nesta postagem, orientamos você nas etapas envolvidas na criação de um modelo CloudFormation para um bot do Amazon Lex V2.

Visão geral da solução

Nós escolhemos o Reservar viagem bot como ponto de partida para este exercício. Usamos um modelo CloudFormation para criar um novo bot do zero, incluindo a definição de intenções, slots e outros componentes necessários. Além disso, exploramos tópicos como controle de versão, aliases, integração AWS Lambda funções, criando ramificações condicionais e habilitando o registro em log.

Pré-requisitos

Você deve ter os seguintes pré-requisitos:

  • An Conta da AWS para criar e implantar um modelo CloudFormation
  • O necessário Gerenciamento de acesso e identidade da AWS (IAM) permissões para implantar o AWS CloudFormation e os recursos usados ​​no modelo
  • Conhecimento básico do Amazon Lex, funções Lambda e serviços associados
  • Conhecimento básico de criação e implantação de modelos CloudFormation

Crie uma função do IAM

Para começar, você precisa criar uma função IAM que o bot usará. Você pode conseguir isso inicializando um modelo CloudFormation e adicionando a função IAM como um recurso. Você pode usar o modelo a seguir para criar a função. Se você baixe o modelo de exemplo e implantá-lo, você verá que uma função IAM foi criada. Fornecemos exemplos de modelos à medida que avançamos nesta postagem e os mesclamos à medida que avançamos.

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: CloudFormation template for book hotel bot.
Resources:
  # 1. IAM role that is used by the bot at runtime
  BotRuntimeRole:    
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lexv2.amazonaws.com
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: LexRuntimeRolePolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - "polly:SynthesizeSpeech"
                  - "comprehend:DetectSentiment"
                Resource: "*"

Configurar o bot do Amazon Lex

Em seguida, você precisa adicionar a definição do bot. A seguir está o modelo YAML para a definição de bot do Amazon Lex; você constrói os componentes necessários um por um:

Type: AWS::Lex::Bot
Properties:
  AutoBuildBotLocales: Boolean
  BotFileS3Location: 
    S3Location
  BotLocales: 
    - BotLocale
  BotTags: 
    - Tag
  DataPrivacy: 
    DataPrivacy
  Description: String
  IdleSessionTTLInSeconds: Integer
  Name: String
  RoleArn: String
  TestBotAliasSettings: 
    TestBotAliasSettings
  TestBotAliasTags: 
    - Tag

Para criar um bot que inclua apenas a definição do bot sem qualquer intenção, você pode usar o modelo a seguir. Aqui, você especifica o nome do bot, o ARN da função criada anteriormente, as configurações de privacidade de dados e muito mais:

BookHotelBot:
    DependsOn: BotRuntimeRole # The role created in the previous step
    Type: AWS::Lex::Bot
    Properties:
      Name: "BookHotel"
      Description: "Sample Bot to book a hotel"
      RoleArn: !GetAtt BotRuntimeRole.Arn      
      #For each Amazon Lex bot created with the Amazon Lex Model Building Service, you must specify whether your use of Amazon Lex 
      #is related to a website, program, or other application that is directed or targeted, in whole or in part, to children under 
      #age 13 and subject to the Children's Online Privacy Protection Act (COPPA) by specifying true or false in the 
      #childDirected field.
      DataPrivacy:
        ChildDirected: false
      IdleSessionTTLInSeconds: 300

Você pode baixe o modelo atualizado. A implantação do modelo atualizado permite criar a função e a definição do bot. Observe que você está atualizando a pilha você criou na etapa anterior.

A etapa final envolve a definição do BotLocales, que constituem a maior parte da funcionalidade do bot. Isto inclui, por exemplo, Intents e Slot types. A seguir está o modelo YAML:

  CustomVocabulary: 
    CustomVocabulary
  Description: String
  Intents: 
    - Intent
  LocaleId: String
  NluConfidenceThreshold: Number
  SlotTypes: 
    - SlotType
  VoiceSettings: 
    VoiceSettings

Neste caso, você constrói o BookHotel intenção, que requer um tipo de slot personalizado para tipos de quarto. Você definiu o LocaleId, Em seguida, o VoiceSettings. Então você adiciona o SlotTypes e seus valores correspondentes.

A próxima etapa é definir o Intents, começando com a primeira intenção, BookHotel, que envolve adicionar enunciados, slots e prioridades de slots. Os detalhes desses nós são demonstrados no modelo fornecido. Finalmente, você adiciona a segunda intenção, que é a FallbackIntent. Veja o seguinte código:

BotLocales:
        - LocaleId: "en_US"
          Description: "en US locale"
          NluConfidenceThreshold: 0.40
          VoiceSettings:
            VoiceId: "Matthew"
          SlotTypes:
            - Name: "RoomTypeValues"
              Description: "Type of room"
              SlotTypeValues:
                - SampleValue:
                    Value: queen
                - SampleValue:
                    Value: king
                - SampleValue:
                    Value: deluxe
              ValueSelectionSetting:
                ResolutionStrategy: ORIGINAL_VALUE
          Intents:
            - Name: "BookHotel"
              Description: "Intent to book a hotel room"
              SampleUtterances:
                - Utterance: "Book a hotel"
                - Utterance: "I want a make hotel reservations"
                - Utterance: "Book a {Nights} night stay in {Location}"
              IntentConfirmationSetting:
                PromptSpecification:
                  MessageGroupsList:
                    - Message:
                        PlainTextMessage:
                          Value: "Okay, I have you down for a {Nights} night stay in {Location} starting {CheckInDate}.  Shall I book the reservation?"
                  MaxRetries: 3
                  AllowInterrupt: false
                DeclinationResponse:
                  MessageGroupsList:
                    - Message:
                        PlainTextMessage:
                          Value: "Okay, I have cancelled your reservation in progress."
                  AllowInterrupt: false
              SlotPriorities:
                - Priority: 1
                  SlotName: Location
                - Priority: 2
                  SlotName: CheckInDate
                - Priority: 3
                  SlotName: Nights
                - Priority: 4
                  SlotName: RoomType
              Slots:
                - Name: "Location"
                  Description: "Location of the city in which the hotel is located"
                  SlotTypeName: "AMAZON.City"
                  ValueElicitationSetting:
                    SlotConstraint: "Required"
                    PromptSpecification:
                      MessageGroupsList:
                        - Message:
                            PlainTextMessage:
                              Value: "What city will you be staying in?"
                      MaxRetries: 2
                      AllowInterrupt: false
                - Name: "CheckInDate"
                  Description: "Date of check-in"
                  SlotTypeName: "AMAZON.Date"
                  ValueElicitationSetting:
                    SlotConstraint: "Required"
                    PromptSpecification:
                      MessageGroupsList:
                        - Message:
                            PlainTextMessage:
                              Value: "What day do you want to check in?"
                      MaxRetries: 2
                      AllowInterrupt: false
                - Name: "Nights"
                  Description: "something"
                  SlotTypeName: "AMAZON.Number"
                  ValueElicitationSetting:
                    SlotConstraint: "Required"
                    PromptSpecification:
                      MessageGroupsList:
                        - Message:
                            PlainTextMessage:
                              Value: "How many nights will you be staying?"
                      MaxRetries: 2
                      AllowInterrupt: false
                - Name: "RoomType"
                  Description: "Enumeration of types of rooms that are offered by a hotel."
                  SlotTypeName: "RoomTypeValues"
                  ValueElicitationSetting:
                    SlotConstraint: "Required"
                    PromptSpecification:
                      MessageGroupsList:
                        - Message:
                            PlainTextMessage:
                              Value: "What type of room would you like, queen, king or deluxe?"
                      MaxRetries: 2
                      AllowInterrupt: false
            - Name: "FallbackIntent"
              Description: "Default intent when no other intent matches"
              ParentIntentSignature: "AMAZON.FallbackIntent"

Você pode baixe o modelo do CloudFormation pelo trabalho realizado até agora. Depois de você atualize sua pilha com este modelo, um bot funcional será implantado. No console do Amazon Lex, você pode confirmar se há uma versão de rascunho do bot e um alias padrão chamado TestBotAlias foi criado.

alias do bot

Crie uma nova versão e alias do bot

Amazon Lex oferece suporte à publicação versões de bots, intenções e tipos de slots para que você possa controlar a implementação de seus aplicativos clientes. Uma versão é um instantâneo numerado da definição do seu bot que você pode publicar para uso em diferentes partes do seu fluxo de trabalho, como desenvolvimento, implantação beta e produção. Os bots do Amazon Lex também oferecem suporte aliases. Um alias é um ponteiro para uma versão específica de um bot. Com um alias, você pode atualizar a versão dos seus aplicativos clientes. Em cenários práticos, os aliases de bot são usados ​​para implantações azuis/verdes e para gerenciar configurações específicas do ambiente, como ambientes de desenvolvimento e produção.

Para ilustrar, digamos que você aponte um alias para a versão 1 do seu bot. Quando chegar a hora de atualizar o bot, você poderá publicar a versão 2 e alterar o alias para apontar para a nova versão. Como seus aplicativos usam o alias em vez de uma versão específica, todos os clientes recebem a nova funcionalidade sem precisar de atualizações.

Lembre-se de que quando você modifica o modelo CloudFormation e inicia a implantação, as alterações são implementadas na versão de rascunho, destinada principalmente para teste. Depois de concluir a fase de testes, você poderá estabelecer uma nova versão para finalizar as alterações incorporadas até agora.

Em seguida, você cria uma nova versão do bot com base no seu rascunho, configura um novo alias e vincula a versão a esse alias. A seguir estão os dois novos recursos para adicionar ao seu modelo:

BookHotelInitialVersion:
    DependsOn: BookHotelBot
    Type: AWS::Lex::BotVersion
    Properties:
      BotId: !Ref BookHotelBot
      BotVersionLocaleSpecification:
        - LocaleId: en_US
          BotVersionLocaleDetails:
            SourceBotVersion: DRAFT
      Description: Hotel Bot initial version

  BookHotelDemoAlias:
    Type: AWS::Lex::BotAlias
    Properties:
      BotId: !Ref BookHotelBot
      BotAliasName: "BookHotelDemoAlias"
      BotVersion: !GetAtt BookHotelInitialVersion.BotVersion

Você pode baixe a nova versão do modelo e implante-o atualizando sua pilha. Você pode ver no console do Amazon Lex que uma nova versão é criada e associada a um novo alias chamado BookHotelDemoAlias.

alias de demonstração

Quando você cria uma nova versão de um bot do Amazon Lex, normalmente o número da versão é incrementado sequencialmente, começando em 1. Para discernir uma versão específica, você pode consultar sua descrição.

versão inicial

Adicionar uma função Lambda

Para inicializar valores ou validar a entrada do usuário para seu bot, você pode adicionar uma função Lambda como um gancho de código ao seu bot. Da mesma forma, você também pode usar uma função Lambda para atendimento, por exemplo, gravar dados em bancos de dados ou chamar APIs para salvar as informações coletadas. Para obter mais informações, consulte Habilitar lógica personalizada com funções do AWS Lambda.

Vamos adicionar um novo recurso para a função Lambda ao modelo CloudFormation. Embora geralmente não seja aconselhável incorporar código em modelos do CloudFormation, fazemos isso aqui apenas para tornar a implantação da demonstração menos complicada. Veja o seguinte código:

HotelBotFunction:
    DependsOn: BotRuntimeRole # So that the Lambda function is ready before the bot deployment
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: book_hotel_lambda
      Runtime: python3.11
      Timeout: 15
      Handler: index.lambda_handler
      InlineCode: |
        import os
        import json

        def close(intent_request):
            intent_request['sessionState']['intent']['state'] = 'Fulfilled'

            message = {"contentType": "PlainText",
                      "content": "Your Booking is confirmed"}

            session_attributes = {}
            sessionState = intent_request['sessionState']
            if 'sessionAttributes' in sessionState:
                session_attributes = sessionState['sessionAttributes']

            requestAttributes = None
            if 'requestAttributes' in intent_request:
                requestAttributes = intent_request['requestAttributes']

            return {
                'sessionState': {
                    'sessionAttributes': session_attributes,
                    'dialogAction': {
                        'type': 'Close'
                    },
                    'intent': intent_request['sessionState']['intent'],
                    'originatingRequestId': 'xxxxxxx-xxxx-xxxx-xxxx'
                },
                'messages':  [message],
                'sessionId': intent_request['sessionId'],
                'requestAttributes': requestAttributes
            }

        def router(event):
            intent_name = event['sessionState']['intent']['name']
            slots = event['sessionState']['intent']['slots']
            if (intent_name == 'BookHotel'):
                # invoke lambda and return result
                return close(event)

            raise Exception(
                'The intent is not supported by Lambda: ' + intent_name)

        def lambda_handler(event, context):
            response = router(event)
            return response

Para usar esta função Lambda para o cumprimento, habilite as configurações de gancho de código em sua intenção:

Intents:
  - Name: "BookHotel"
    Description: "Intent to book a hotel room"
    FulfillmentCodeHook:
      Enabled: true
    SampleUtterances:
      - Utterance: "Book a hotel"
      - Utterance: "I want a make hotel reservations"
      - Utterance: "Book a {Nights} night stay in {Location}"

Como você fez alterações no seu bot, você pode criar uma nova versão do bot adicionando um novo recurso chamado BookHotelVersionWithLambda no modelo:

BookHotelVersionWithLambda:
    DependsOn: BookHotelInitialVersion
    Type: AWS::Lex::BotVersion
    Properties:
      BotId: !Ref BookHotelBot
      BotVersionLocaleSpecification:
        - LocaleId: en_US
          BotVersionLocaleDetails:
            SourceBotVersion: DRAFT
      Description: Hotel Bot with a lambda function

A função Lambda está associada a um alias de bot. O Amazon Lex V2 pode usar uma função do Lambda por alias de bot e por idioma. Portanto, você deve atualizar seu alias no modelo para adicionar o recurso da função Lambda. Você pode fazer isso no BotAliasLocalSettings seção. Você também precisa apontar o alias para a nova versão criada. O código a seguir é a configuração do alias modificada:

  BookHotelDemoAlias:
    Type: AWS::Lex::BotAlias
    Properties:
      BotId: !Ref BookHotelBot
      BotAliasName: "BookHotelDemoAlias"
      BotVersion: !GetAtt BookHotelVersionWithLambda.BotVersion
      # Remove BotAliasLocaleSettings if you aren't concerned with Lambda setup.
      # If you are you can modify the LambdaArn below to get started.
      BotAliasLocaleSettings:
        - LocaleId: en_US
          BotAliasLocaleSetting:
            Enabled: true
            CodeHookSpecification:
              LambdaCodeHook:
                CodeHookInterfaceVersion: "1.0"
                LambdaArn: !GetAtt HotelBotFunction.Arn

Até agora, você vinculou apenas a função Lambda ao alias. No entanto, você precisa conceder permissão para permitir que o alias invoque a função Lambda. No código a seguir, você adiciona a permissão de invocação do Lambda para o Amazon Lex e especifica o ARN do alias como o ARN de origem:

  LexInvokeLambdaPermission:
    Type: AWS::Lambda::Permission
    Properties:
      Action: "lambda:InvokeFunction"
      FunctionName: !GetAtt HotelBotFunction.Arn
      Principal: "lexv2.amazonaws.com"
      SourceArn: !GetAtt BookHotelDemoAlias.Arn

Você pode baixe a última versão do modelo. Depois de atualizar sua pilha com esta versão, você terá um bot Amazon Lex integrado a uma função Lambda.

segunda versão

alis atualizado

Ramos condicionais

Agora vamos explorar o recurso de ramificação condicional do bot do Amazon Lex e considerar um cenário em que a reserva de mais de cinco noites em Seattle não seja permitida para a próxima semana. De acordo com os requisitos comerciais, a conversa deverá terminar com uma mensagem apropriada se o usuário tentar reservar mais de cinco noites em Seattle. A ramificação condicional para isso é representada no modelo CloudFormation sob o SlotCaptureSetting:

- Name: "Nights"
                  Description: “Number of nights.”
                  SlotTypeName: "AMAZON.Number"
                  ValueElicitationSetting:
                    SlotConstraint: "Required"
                    SlotCaptureSetting:
                      CaptureConditional:
                        DefaultBranch:
                          NextStep:
                            DialogAction:
                              Type: "ElicitSlot"
                              SlotToElicit: "RoomType"
                        ConditionalBranches:
                          - Name: "Branch1"
                            Condition:
                              ExpressionString: '{Nights}>5 AND {Location} = "Seattle"'
                            Response:
                              AllowInterrupt: true
                              MessageGroupsList:
                                - Message:
                                    PlainTextMessage:
                                      Value: “Sorry, we cannot book more than five nights in {Location} right now."
                            NextStep:
                              DialogAction:
                                Type: "EndConversation"
                        IsActive: true

                    PromptSpecification:
                      MessageGroupsList:
                        - Message:
                            PlainTextMessage:
                              Value: "How many nights will you be staying?"
                      MaxRetries: 2
                      AllowInterrupt: false

Como você alterou a definição do bot, será necessário criar uma nova versão no modelo e vinculá-la ao alias. Esta é uma modificação temporária porque a empresa planeja permitir grandes reservas em Seattle em breve. A seguir estão os dois novos recursos que você adiciona ao modelo:

BookHotelConditionalBranches:
    DependsOn: BookHotelVersionWithLambda
    Type: AWS::Lex::BotVersion
    Properties:
      BotId: !Ref BookHotelBot
      BotVersionLocaleSpecification:
        - LocaleId: en_US
          BotVersionLocaleDetails:
            SourceBotVersion: DRAFT
      Description: Hotel Bot Version with conditional branches

  BookHotelDemoAlias:
    Type: AWS::Lex::BotAlias
    Properties:
      BotId: !Ref BookHotelBot
      BotAliasName: "BookHotelDemoAlias"
      BotVersion: !GetAtt BookHotelConditionalBranches.BotVersion
      # Remove BotAliasLocaleSettings if you aren't concerned with Lambda setup.
      # If you are you can modify the LambdaArn below to get started.
      BotAliasLocaleSettings:
        - LocaleId: en_US
          BotAliasLocaleSetting:
            Enabled: true
            CodeHookSpecification:
              LambdaCodeHook:
                CodeHookInterfaceVersion: "1.0"
                LambdaArn: !GetAtt HotelBotFunction.Arn

Você pode baixe o modelo atualizado. Depois de atualizar sua pilha com esta versão do modelo, o alias será direcionado para a versão que incorpora o recurso de ramificação condicional. Para desfazer esta modificação, você pode atualizar o alias para reverter para a versão anterior.

terceira versão

alias para terceira versão

Logs

Você também pode habilitar logs para seu bot do Amazon Lex. Para fazer isso, você deve atualizar a função do bot para conceder permissões de escrita Amazon CloudWatch Histórico. Veja a seguir um exemplo de adição de uma política do CloudWatch à função:

BotRuntimeRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lexv2.amazonaws.com
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: LexRuntimeRolePolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - "polly:SynthesizeSpeech"
                  - "comprehend:DetectSentiment"
                Resource: "*"
        - PolicyName: CloudWatchPolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - "logs:CreateLogStream"
                  - "logs:PutLogEvents"
                Resource: "*"

Para garantir um comportamento consistente e previsível, você deve ser o mais específico possível ao definir nomes e propriedades de recursos em modelos do CloudFormation. Isso ocorre porque o uso do caractere curinga (*) em modelos do CloudFormation pode representar riscos potenciais à segurança e levar a consequências indesejadas. Portanto, é recomendado evitar o uso de curingas e, em vez disso, usar valores explícitos sempre que possível.

Em seguida, você cria um recurso de grupo de logs do CloudWatch, conforme mostrado no código a seguir, para direcionar seus logs para esse grupo:

  #Log Group
  LexLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: /lex/hotel-bot
      RetentionInDays: 5

Por fim, você atualiza seu alias para ativar as configurações de registro de conversas:

BookHotelDemoAlias:
    Type: AWS::Lex::BotAlias
    Properties:
      BotId: !Ref BookHotelBot
      BotAliasName: "BookHotelDemoAlias"
      BotVersion: !GetAtt BookHotelConditionalBranches.BotVersion
      BotAliasLocaleSettings:
        - LocaleId: en_US
          BotAliasLocaleSetting:
            Enabled: true
            CodeHookSpecification:
              LambdaCodeHook:
                CodeHookInterfaceVersion: "1.0"
                LambdaArn: !GetAtt HotelBotFunction.Arn
      ConversationLogSettings:
        TextLogSettings:
          - Destination:
              CloudWatch:
                CloudWatchLogGroupArn: !GetAtt LexLogGroup.Arn
                LogPrefix: bookHotel
            Enabled: true

Ao atualizar a pilha com este modelo, você habilita os logs de conversa para seu bot. Uma nova versão não é criada nesta etapa porque não há alterações no recurso do bot. Você pode baixe a versão mais recente do modelo.

Clean Up

Para evitar cobranças futuras, exclua a pilha do CloudFormation que você criou.

Conclusão

Nesta postagem, discutimos o processo passo a passo para criar um modelo CloudFormation para um bot Amazon Lex V2. Inicialmente, implantamos um bot básico, depois exploramos o potencial de aliases e versões e como usá-los de forma eficiente com modelos. A seguir, aprendemos como integrar uma função do Lambda a um bot do Amazon Lex V2 e implementar a ramificação condicional no fluxo de conversa do bot para acomodar os requisitos de negócios. Por fim, adicionamos recursos de registro criando um recurso de grupo de logs do CloudWatch e atualizando a função do bot com as permissões necessárias.

O modelo permite a implantação e o gerenciamento simples do bot, com a capacidade de reverter as alterações conforme necessário. No geral, o modelo CloudFormation é útil para gerenciar e otimizar um bot do Amazon Lex V2.

Na próxima etapa, você pode explorar exemplos de bots do Amazon Lex e aplique as técnicas discutidas nesta postagem para convertê-las em modelos CloudFormation. Esta prática prática solidificará sua compreensão do gerenciamento de bots do Amazon Lex V2 por meio de infraestrutura como código.

Sobre os autores

Gerencie seu bot do Amazon Lex por meio de modelos do AWS CloudFormation | Inteligência de dados PlatoBlockchain da Amazon Web Services. Pesquisa vertical. Ai.Thomas Rindfuss é arquiteto de soluções sênior na equipe do Amazon Lex. Ele inventa, desenvolve, prototipa e evangeliza novos recursos técnicos e soluções para serviços de Language AI que melhoram a experiência do cliente e facilitam a adoção.

Gerencie seu bot do Amazon Lex por meio de modelos do AWS CloudFormation | Inteligência de dados PlatoBlockchain da Amazon Web Services. Pesquisa vertical. Ai.Rijeesh Akkambeth Chathoth é consultor de serviços profissionais na AWS. Ele ajuda os clientes a alcançar o negócio desejado
resultados no espaço do Contact Center aproveitando os recursos do Amazon Connect, Amazon Lex e GenAI.

Carimbo de hora:

Mais de Aprendizado de máquina da AWS