`, uma [notificação do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) invoca a função do Lambda `data-ingestion-processor`.
1. A função do Lambda `data-ingestion-processor` é baseada em uma imagem do Docker armazenada no repositório `bedrock-rag-template` do Amazon Elastic Container Registry (Amazon ECR).
A função usa o [LangChain S3 FileLoader](https://python.langchain.com/v0.1/docs/integrations/document_loaders/aws_s3_file/) para ler o arquivo como um [LangChain documento](https://api.python.langchain.com/en/v0.0.339/schema/langchain.schema.document.Document.html). Em seguida, [LangChain RecursiveCharacterTextSplitter](https://python.langchain.com/v0.1/docs/modules/data_connection/document_transformers/recursive_text_splitter/)fragmente cada documento, dados a `CHUNK_SIZE` e a, dependendo do tamanho máximo do token do modelo de incorporação Amazon Titan Text Embedding V2. `CHUNK_OVERLAP` Em seguida, a função do Lambda invoca o modelo de incorporação no Amazon Bedrock para transformar os blocos em representações vetoriais numéricas. Por fim, esses vetores são armazenados no banco de dados do Aurora PostgreSQL. Para acessar o banco de dados, a função Lambda primeiro recupera o nome de usuário e a senha de. AWS Secrets Manager
1. Na [instância do notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) Amazon SageMaker AI`aws-sample-bedrock-rag-template`, o usuário pode escrever uma solicitação de pergunta. O código invoca o Claude 3 no Amazon Bedrock e adiciona as informações da base de conhecimento ao contexto do prompt. Como resultado, o Claude 3 fornece respostas com base nas informações contidas nos documentos.
A abordagem deste padrão em relação à rede e à segurança é a seguinte:
+ A função do Lambda `data-ingestion-processor` está em uma sub-rede privada na nuvem privada virtual (VPC). A função do Lambda não tem permissão para enviar tráfego para a internet pública devido ao seu grupo de segurança. Como resultado, o tráfego destinado ao Amazon S3 e ao Amazon Bedrock é roteado apenas pelos endpoints da VPC. Dessa forma, o tráfego não passa pela internet pública, diminuindo a latência e oferecendo uma camada adicional de segurança na rede.
+ Todos os recursos e dados são criptografados sempre que aplicável usando a chave AWS Key Management Service (AWS KMS) com o alias`aws-sample/bedrock-rag-template`.
**Automação e escala**
Esse padrão usa o Terraform para implantar a infraestrutura do repositório de código em uma Conta da AWS.
## Ferramentas
**Serviços da AWS**
+ O [Amazon Aurora Edição Compatível com PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) é um mecanismo de banco de dados relacional totalmente gerenciado e compatível com ACID que ajuda você a configurar, operar e escalar implantações do PostgreSQL. Neste padrão, o Aurora compatível com PostgreSQL faz uso do plug-in “pgvector” como banco de dados de vetores.
+ [O Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) é um serviço totalmente gerenciado que disponibiliza modelos básicos de alto desempenho (FMs) das principais startups de IA e da Amazon para seu uso por meio de uma API unificada.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando.
+ O [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) é um serviço gerenciado de registro de imagens de contêineres seguro, escalável e confiável. Neste padrão, o Amazon ECR hospeda a imagem do Docker da função do Lambda `data-ingestion-processor`.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ajuda você a gerenciar com segurança o acesso aos seus AWS recursos controlando quem está autenticado e autorizado a usá-los.
+ O [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ajuda na criação e no controle de chaves criptográficas, contribuindo para a proteção dos seus dados.
+ O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado. Neste padrão, a Lambda ingere dados no armazenamento de vetores.
+ O [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) é um serviço gerenciado de aprendizado de máquina (ML) que ajuda você a criar e treinar modelos de ML e depois implantá-los em um ambiente hospedado pronto para produção.
+ O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda a substituir credenciais codificadas, incluindo senhas, por uma chamada de API ao Secrets Manager para recuperar o segredo por programação.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
+ [A Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ajuda você a lançar AWS recursos em uma rede virtual que você definiu. Essa rede virtual é semelhante a uma rede tradicional que você operaria no próprio datacenter, com os benefícios de usar a infraestrutura escalável da AWS. A VPC inclui sub-redes e tabelas de rotas para controlar o fluxo de tráfego.
**Outras ferramentas**
+ O [Docker](https://docs.docker.com/manuals/) é um conjunto de produtos de plataforma como serviço (PaaS) que usam a virtualização no nível do sistema operacional para fornecer software em contêineres.
+ O [HashiCorp Terraform](https://www.terraform.io/docs) é uma ferramenta de infraestrutura como código (IaC) que ajuda a provisionar e gerenciar recursos e infraestrutura de nuvem por meio de código.
+ O [Poetry](https://pypi.org/project/poetry/) é uma ferramenta para gerenciamento de dependências e empacotamento em Python.
+ [Python](https://www.python.org/) é uma linguagem de programação de computador de uso geral.
**Repositório de código**
O código desse padrão está disponível no repositório GitHub [terraform-rag-template-using-amazon-bedrock](https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock).
## Práticas recomendadas
+ Embora esse exemplo de código possa ser implantado em qualquer um Região da AWS, recomendamos que você use o Leste dos EUA (Norte da Virgínia) `us-east-1` ou Oeste dos EUA (Norte da Califórnia). `us-west-1` Essa recomendação baseia-se na disponibilidade de modelos de base e de modelos de incorporação no Amazon Bedrock no momento da publicação deste padrão. Para obter uma up-to-date lista do suporte ao modelo da Amazon Bedrock Foundation em Regiões da AWS, consulte [Model support by Região da AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) na documentação do Amazon Bedrock. Para obter informações sobre como implantar esta amostra de código em outras regiões, consulte [Informações adicionais](#deploy-rag-use-case-on-aws-additional).
+ Esse padrão fornece somente uma demonstração proof-of-concept (PoC) ou piloto. Se você pretende implantar o código para produção, certifique-se de seguir as seguintes práticas recomendadas:
+ Habilite o registro em log de acesso ao servidor para o Amazon S3.
+ Configure [o monitoramento e a geração de alertas](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html) para a função do Lambda.
+ Se seu caso de uso exigir uma API, considere adicionar o Amazon API Gateway junto com uma função do Lambda que execute tarefas de recuperação e de resposta a perguntas.
+ Respeite o princípio de privilégio mínimo, garantindo somente as permissões estritamente necessárias para a execução de uma tarefa. Para obter mais informações, consulte [Concessão de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e [Práticas recomendadas de segurança](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html) na documentação do IAM.
## Épicos
### Implemente a solução em um Conta da AWS
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Clonar o repositório. | Para clonar o GitHub repositório fornecido com esse padrão, use o seguinte comando:git clone https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock
| AWS DevOps |
| Configure as variáveis. | Para configurar os parâmetros deste padrão, execute as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | AWS DevOps |
| Implante a solução. | Para implantar a solução, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)A implantação da infraestrutura provisiona uma instância de SageMaker IA dentro da VPC e com as permissões para acessar o banco de dados Aurora PostgreSQL. | AWS DevOps |
### Testar a solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Execute a demonstração. | Após a implantação da infraestrutura anterior ter sido concluída com êxito, siga as seguintes etapas para executar a demonstração em um caderno Jupyter:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)O caderno Jupyter orienta você pelo seguinte processo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | AWS geral |
### Limpeza da infraestrutura
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Limpe a infraestrutura. | Para remover todos os recursos que você criou quando não forem mais necessários, use o seguinte comando:terraform destroy -var-file=commons.tfvars
| AWS DevOps |
## Recursos relacionados
**AWS recursos**
+ [Criar funções do Lambda com Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Parâmetros de inferência para modelos de fundação](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Acessar modelos de base do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [O papel dos bancos de dados vetoriais em aplicativos generativos de IA](https://aws.amazon.com/blogs/database/the-role-of-vector-datastores-in-generative-ai-applications/) (AWS Database Blog)
+ [Trabalho com Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html)
**Outros recursos**
+ [Documentação do pgvector](https://github.com/pgvector/pgvector)
## Mais informações
**Implementação de um banco de dados de vetores**
Este padrão usa o Aurora compatível com PostgreSQL para implementar um banco de dados de vetores para RAG. Como alternativa ao Aurora PostgreSQL, AWS fornece outros recursos e serviços para o RAG, como o Amazon Bedrock Knowledge Bases e o Amazon Service. OpenSearch Você pode escolher a solução que melhor se adapta aos seus requisitos específicos:
+ O [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) fornece mecanismos distribuídos de pesquisa e análise que você pode usar para armazenar e consultar grandes volumes de dados.
+ As [Bases de Conhecimento para Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) foram projetadas para criar e implantar bases de conhecimento como uma camada adicional para simplificar o processo de ingestão e a recuperação da RAG. As bases de conhecimento Amazon Bedrock podem funcionar tanto com o Aurora OpenSearch PostgreSQL quanto com o Amazon Service.
**Implantação em outros Regiões da AWS**
Conforme descrito na seção [Arquitetura](#deploy-rag-use-case-on-aws-architecture), recomendamos que você use a região Leste dos EUA (Norte da Virgínia) (`us-east-1`) ou Oeste dos EUA (N. da Califórnia) (`us-west-1`) para implantar esta amostra de código. No entanto, existem duas formas possíveis de implantar esta amostra de código em regiões diferentes de `us-east-1` e `us-west-1`. É possível configurar a região de implantação no arquivo `commons.tfvars`. Para acesso a modelos base em diferentes regiões, considere as seguintes opções:
+ **Atravessando a internet pública**: se o tráfego puder ser transferido pela internet pública, adicione gateways da internet à VPC. Em seguida, ajuste o grupo de segurança atribuído à função Lambda `data-ingestion-processor` e à instância do notebook SageMaker AI para permitir o tráfego de saída para a Internet pública.
+ **Sem atravessar a internet pública**: para implantar este exemplo em qualquer região diferente de `us-east-1` ou de `us-west-1`, faça o seguinte:
1. Em qualquer uma das regiões `us-east-1` ou `us-west-1`, crie uma VPC adicional, incluindo um endpoint da VPC para `bedrock-runtime`.
1. Crie uma conexão de emparelhamento usando o [emparelhamento da VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) ou um [gateway de trânsito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) para a VPC da aplicação.
1. Ao configurar o cliente boto3 do `bedrock-runtime` em qualquer função do Lambda externa à `us-east-1` ou `us-west-1`, transfira o nome de DNS privado do endpoint da VPC para `bedrock-runtime` em `us-east-1` ou us-west-1 como `endpoint_url` para o cliente boto3.
# Implante a lógica de pré-processamento em um modelo de ML em um único endpoint usando um pipeline de inferência na Amazon SageMaker
*Mohan Gowda Purushothama, Gabriel Rodriguez Garcia e Mateusz Zaremba, Amazon Web Services*
## Resumo
Esse padrão explica como implantar vários objetos de modelo de pipeline em um único endpoint usando um [pipeline de inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) na Amazon. SageMaker O objeto do modelo de pipeline representa diferentes estágios do fluxo de trabalho de machine learning (ML), como pré-processamento, inferência de modelos e pós-processamento. [Para ilustrar a implantação de objetos de modelo de pipeline conectados em série, esse padrão mostra como implantar um contêiner [Scikit-learn](https://docs.aws.amazon.com/sagemaker/latest/dg/sklearn.html) de pré-processamento e um modelo de regressão baseado no algoritmo linear do aluno incorporado.](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) SageMaker A implantação é hospedada por trás de um único endpoint em SageMaker.
**nota**
A implantação neste padrão usa o tipo de instância ml.m4.2xlarge. Recomendamos usar um tipo de instância que se alinhe aos seus requisitos de tamanho de dados e à complexidade do seu fluxo de trabalho. Para obter mais informações, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/). Esse padrão usa [imagens do Docker pré-construídas para o Scikit-learn](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-docker-containers-scikit-learn-spark.html), mas você pode usar seus próprios contêineres do Docker e integrá-los ao seu fluxo de trabalho.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma conta AWS ativa
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
+ [SDK para Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/) [e biblioteca Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Função do AWS Identity and Access Management (AWS IAM) com [permissões](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) básicas e SageMaker [permissões](https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html) do Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-policy-language-overview.html)
**Versões do produto**
+ [SDK 2.49.2 para Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/v2.49.2/)
## Arquitetura
**Pilha de tecnologias de destino**
+ Amazon Elastic Container Registry (Amazon ECR)
+ Amazon SageMaker
+ SageMaker Estúdio Amazon
+ Amazon Simple Storage Service (Amazon S3)
+ Endpoint de [inferência em tempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) para a Amazon SageMaker
**Arquitetura de destino**
O diagrama a seguir mostra a arquitetura para a implantação de um objeto de modelo de SageMaker pipeline da Amazon.
![\[Arquitetura para implantação do objeto de modelo de SageMaker pipeline\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/1105d51b-752f-46d7-962c-acef1fb3399f/images/12f06715-b1c2-4de0-b277-99ce87308152.png)
O diagrama mostra o seguinte fluxo de trabalho:
1. Um SageMaker notebook implanta um modelo de pipeline.
1. Um bucket do S3 armazena os artefatos do modelo.
1. O Amazon ECR obtém as imagens do contêiner de origem do bucket do S3.
## Ferramentas
**Ferramentas da AWS**
+ O [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) é um serviço gerenciado de registro de imagens de contêineres seguro, escalável e confiável.
+ SageMakerA [Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) é um serviço gerenciado de ML que ajuda você a criar e treinar modelos de ML e depois implantá-los em um ambiente hospedado pronto para produção.
+ O [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) é um ambiente de desenvolvimento integrado (IDE) baseado na web para ML que permite criar, treinar, depurar, implantar e monitorar seus modelos de ML.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
**Código **
O código desse padrão está disponível no GitHub [Inference Pipeline com o repositório Scikit-learn e Linear](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.ipynb) Learner.
## Épicos
### Prepare o conjunto de dados
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Prepare o conjunto de dados para sua tarefa de regressão. | [Abra um caderno](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-open) no Amazon SageMaker Studio.Para importar todas as bibliotecas necessárias e inicializar seu ambiente de trabalho, use o código de exemplo a seguir em seu notebook:import sagemaker
from sagemaker import get_execution_role
sagemaker_session = sagemaker.Session()
# Get a SageMaker-compatible role used by this Notebook Instance.
role = get_execution_role()
# S3 prefix
bucket = sagemaker_session.default_bucket()
prefix = "Scikit-LinearLearner-pipeline-abalone-example"
Para baixar um conjunto de dados de exemplo, adicione o seguinte código ao seu caderno:! mkdir abalone_data
! aws s3 cp s3://sagemaker-sample-files/datasets/tabular/uci_abalone/abalone.csv ./abalone_data
** **O exemplo neste padrão usa o [Abalone Data Set](https://archive.ics.uci.edu/ml/datasets/abalone) do UCI Machine Learning Repository. | Cientista de dados |
| Faça upload do conjunto de dados em um bucket do S3. | No caderno em que você preparou seu conjunto de dados anteriormente, adicione o código a seguir para carregar seus dados de amostra em um bucket do S3:WORK_DIRECTORY = "abalone_data"
train_input = sagemaker_session.upload_data(
path="{}/{}".format(WORK_DIRECTORY, "abalone.csv"),
bucket=bucket,
key_prefix="{}/{}".format(prefix, "train"),
)
| Cientista de dados |
### Crie o pré-processador de dados usando SKLearn
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Prepare o script preprocessor.py. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-preprocessing-logic-into-an-ml-model-in-a-single-endpoint-using-an-inference-pipeline-in-amazon-sagemaker.html) | Cientista de dados |
| Crie o objeto do SKLearn pré-processador. | Para criar um objeto SKLearn pré-processador (chamado SKLearn Estimator) que você possa incorporar ao seu pipeline de inferência final, execute o seguinte código em seu notebook: SageMaker from sagemaker.sklearn.estimator import SKLearn
FRAMEWORK_VERSION = "0.23-1"
script_path = "sklearn_abalone_featurizer.py"
sklearn_preprocessor = SKLearn(
entry_point=script_path,
role=role,
framework_version=FRAMEWORK_VERSION,
instance_type="ml.c4.xlarge",
sagemaker_session=sagemaker_session,
)
sklearn_preprocessor.fit({"train": train_input})
| Cientista de dados |
| Teste a inferência do pré-processador. | Para confirmar se seu pré-processador está definido corretamente, inicie um [trabalho de transformação em lote](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html) inserindo o seguinte código em seu SageMaker notebook:# Define a SKLearn Transformer from the trained SKLearn Estimator
transformer = sklearn_preprocessor.transformer(
instance_count=1, instance_type="ml.m5.xlarge", assemble_with="Line", accept="text/csv"
)
# Preprocess training input
transformer.transform(train_input, content_type="text/csv")
print("Waiting for transform job: " + transformer.latest_transform_job.job_name)
transformer.wait()
preprocessed_train = transformer.output_path
| |
### Criar um modelo de machine learning
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Criar um objeto modelo. | Para criar um objeto de modelo com base no algoritmo linear do aluno, insira o seguinte código em seu SageMaker caderno:import boto3
from sagemaker.image_uris import retrieve
ll_image = retrieve("linear-learner", boto3.Session().region_name)
s3_ll_output_key_prefix = "ll_training_output"
s3_ll_output_location = "s3://{}/{}/{}/{}".format(
bucket, prefix, s3_ll_output_key_prefix, "ll_model"
)
ll_estimator = sagemaker.estimator.Estimator(
ll_image,
role,
instance_count=1,
instance_type="ml.m4.2xlarge",
volume_size=20,
max_run=3600,
input_mode="File",
output_path=s3_ll_output_location,
sagemaker_session=sagemaker_session,
)
ll_estimator.set_hyperparameters(feature_dim=10, predictor_type="regressor", mini_batch_size=32)
ll_train_data = sagemaker.inputs.TrainingInput(
preprocessed_train,
distribution="FullyReplicated",
content_type="text/csv",
s3_data_type="S3Prefix",
)
data_channels = {"train": ll_train_data}
ll_estimator.fit(inputs=data_channels, logs=True)
O código anterior recupera a imagem do Docker do Amazon ECR do Registro público do Amazon ECR para o modelo, cria um objeto estimador e, em seguida, usa esse objeto para treinar o modelo de regressão. | Cientista de dados |
### Implanta o pipeline final
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Implantar o modelo de pipeline. | Para criar um objeto de modelo de pipeline (ou seja, um objeto de pré-processador) e implantar o objeto, insira o seguinte código em seu SageMaker notebook:from sagemaker.model import Model
from sagemaker.pipeline import PipelineModel
import boto3
from time import gmtime, strftime
timestamp_prefix = strftime("%Y-%m-%d-%H-%M-%S", gmtime())
scikit_learn_inferencee_model = sklearn_preprocessor.create_model()
linear_learner_model = ll_estimator.create_model()
model_name = "inference-pipeline-" + timestamp_prefix
endpoint_name = "inference-pipeline-ep-" + timestamp_prefix
sm_model = PipelineModel(
name=model_name, role=role, models= [scikit_learn_inferencee_model, linear_learner_model]
)
sm_model.deploy(initial_instance_count=1, instance_type="ml.c4.xlarge", endpoint_name=endpoint_name)
É possível ajustar o tipo de instância usado no objeto do modelo para atender às suas necessidades. | Cientista de dados |
| Teste a inferência | Para confirmar se o endpoint está funcionando corretamente, execute o seguinte exemplo de código de inferência em seu SageMaker notebook:from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer
payload = "M, 0.44, 0.365, 0.125, 0.516, 0.2155, 0.114, 0.155"
actual_rings = 10
predictor = Predictor(
endpoint_name=endpoint_name, sagemaker_session=sagemaker_session, serializer=CSVSerializer()
)
print(predictor.predict(payload))
| Cientista de dados |
## Recursos relacionados
+ [Pré-processe os dados de entrada antes de fazer previsões usando os pipelines de SageMaker inferência da Amazon e o Scikit-learn (blog do AWS](https://aws.amazon.com/blogs/machine-learning/preprocess-input-data-before-making-predictions-using-amazon-sagemaker-inference-pipelines-and-scikit-learn/) Machine Learning)
+ [Machine Learning de ponta a ponta com a Amazon SageMaker](https://github.com/aws-samples/amazon-sagemaker-build-train-deploy) (GitHub)
# Implemente a validação de segurança de codificação em tempo real usando um servidor MCP com Kiro e outros assistentes de codificação
*Ivan Girardi e Iker Reina Fuente, Amazon Web Services*
## Resumo
Esse padrão descreve como implementar um servidor Model Context Protocol (MCP) que integra três ferramentas de verificação de segurança padrão do setor para fornecer uma análise abrangente de segurança de código. O servidor permite que assistentes de codificação de IA (como Kiro, Amazon Q Developer e Cline) digitalizem automaticamente trechos de código e configurações de infraestrutura como código (IaC). Com essas verificações, os assistentes de codificação podem ajudar a identificar vulnerabilidades de segurança, configurações incorretas e violações de conformidade.
Geradores de código de IA treinados em milhões de trechos de código criam um ponto cego de segurança. Quão seguros eram esses dados de treinamento? Esse padrão fornece validação de segurança em tempo real durante a geração do código, ajudando os desenvolvedores a identificar e entender possíveis problemas de segurança à medida que codificam. Essa abordagem ajuda os desenvolvedores a lidar com as vulnerabilidades diretas e os riscos herdados das dependências. Ao preencher a lacuna entre a eficiência da IA e a conformidade com a segurança, esse padrão ajuda a permitir a adoção segura de ferramentas de desenvolvimento baseadas em IA.
Esse padrão ajuda as organizações a aprimorar suas práticas de segurança de desenvolvimento por meio de ferramentas de codificação assistidas por IA, fornecendo recursos contínuos de verificação de segurança em várias linguagens de programação e definições de infraestrutura. A solução combina os recursos das seguintes ferramentas:
+ Checkov para escanear arquivos IaC, incluindo manifestos do Terraform e do AWS CloudFormation Kubernetes
+ Semgrep para analisar várias linguagens de programação, como Python JavaScript, Java e outras
+ Bandit para escaneamento de segurança especializado em Python
Os principais recursos dessa solução incluem o seguinte:
+ Escaneamento delta de novos segmentos de código, reduzindo a sobrecarga computacional
+ Ambientes isolados de ferramentas de segurança, evitando a contaminação entre ferramentas
+ Integração perfeita com assistentes de codificação de IA (Kiro, Amazon Q Developer, Cline e outros)
+ Feedback de segurança em tempo real durante a geração do código
+ Regras de varredura personalizáveis para conformidade organizacional
O padrão fornece uma interface unificada para verificação de segurança com formatos de resposta padronizados, facilitando a integração das verificações de segurança nos fluxos de trabalho de desenvolvimento. O padrão usa Python e a estrutura MCP para fornecer feedback de segurança automatizado. Essa abordagem ajuda os desenvolvedores a identificar e resolver problemas de segurança no início do processo de desenvolvimento, enquanto aprendem sobre as melhores práticas de segurança por meio de descobertas detalhadas.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Um ativo Conta da AWS com acesso para usar o Kiro ou o Amazon Q Developer, se você quiser usar qualquer um desses assistentes de codificação
+ [Python versão 3.10 ou posterior instalada](https://www.python.org/downloads/)
+ `uv`gerenciador de pacotes [instalado](https://docs.astral.sh/uv/getting-started/installation/)
+ Familiaridade com ferramentas e conceitos de escaneamento de segurança
+ Compreensão básica de IaC e segurança de aplicativos
**Limitações**
+ O escaneamento do Bandit é limitado somente aos arquivos Python.
+ A varredura em tempo real pode afetar o desempenho de grandes bases de código.
+ As limitações específicas da ferramenta são baseadas nos formatos e idiomas de arquivo suportados.
+ A revisão manual é necessária para validar as descobertas de segurança.
+ Os resultados da verificação de segurança exigem experiência em segurança para uma interpretação adequada.
+ Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [AWS Services by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado.
**Versões do produto**
+ Python versão 3.10 ou versões posteriores
+ Checkov versão 3.0.0 ou posterior
+ Semgrep versão 1.45.0 ou posterior
+ Bandit versão 1.7.5 ou posterior
+ MCP [cli] versão 1.11.0 ou posterior
+ Pydantic versão 1.10.0 ou posterior
+ Loguru versão 0.6.0 ou posterior
## Arquitetura
O diagrama apresentado a seguir ilustra a arquitetura para esta solução.
![\[Os assistentes de IA enviam código ao servidor do scanner de segurança MCP para encaminhá-lo para scanners especializados; os resultados da verificação são enviados ao desenvolvedor.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/fa623544-4d54-48af-a4e4-9b6a0624e776/images/9c881f95-76d0-40f6-983e-d987fd2097b8.png)
O diagrama mostra o seguinte fluxo de trabalho:
1. O desenvolvedor usa assistentes de IA (por exemplo, Kiro, Cline, Amazon Q Developer ou Roo Code) para gerar ou analisar código. O assistente de IA envia o código para verificação de segurança.
1. O servidor do scanner de segurança MCP processa a solicitação roteando-a para o scanner especializado apropriado: Checkov para arquivos IaC, Semgrep para análise de várias linguagens de programação ou Bandit para escaneamento de segurança específico para Python.
1. Os resultados do scanner com descobertas de segurança, níveis de severidade, descrições detalhadas e correções sugeridas são enviados de volta ao desenvolvedor por meio do assistente de IA.
1. Um ciclo de feedback contínuo é estabelecido em que o desenvolvedor recebe validação de segurança em tempo real, permitindo correções automatizadas por meio de assistentes de IA e promovendo as melhores práticas de segurança durante o desenvolvimento.
A arquitetura reduz os seguintes riscos comuns de segurança:
+ Injeção de comando
+ Injeção imediata
+ Percurso transversal
+ Ataques de dependência
+ Esgotamento de recursos
A arquitetura reduz esses riscos comuns de segurança implementando as seguintes melhores práticas:
+ Todas as entradas do usuário e do modelo de IA são gravadas em arquivos temporários.
+ Nenhuma entrada direta é fornecida aos comandos da interface de linha de comando (CLI).
+ O acesso ao sistema de arquivos é restrito somente a diretórios e arquivos temporários.
+ Os arquivos temporários são limpos automaticamente.
+ As respostas de digitalização são higienizadas.
+ O isolamento do processo que restringe as capacidades do processo é imposto.
+ Todas as atividades de escaneamento são registradas.
**Automação e escala**
O padrão oferece suporte à automação por meio dos seguintes recursos:
+ Integração com assistentes de codificação de IA para digitalização automática de código
+ Respostas de API padronizadas para processamento automatizado
+ Configuração por meio de arquivos de configuração MCP
+ Support para processamento em lote de vários arquivos
+ Digitalização escalável em várias linguagens de programação e formatos IaC
O processo de digitalização pode ser automatizado por meio dos endpoints de API fornecidos:
+ `scan_with_checkov`para digitalização IaC
+ `scan_with_semgrep`para digitalização de código em vários idiomas
+ `scan_with_bandit`para escaneamento específico do Python
+ `get_supported_formats`para validação de formato
Ao estender as ferramentas de digitalização, siga os princípios de design e as melhores práticas descritos anteriormente nesta seção. Veja também [as melhores práticas](#deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants-best-practices).
## Ferramentas
**Serviços da AWS**
+ O [Kiro](https://aws.amazon.com/documentation-overview/kiro/) é um serviço de codificação agente que trabalha junto com desenvolvedores para transformar solicitações em especificações detalhadas e, em seguida, em código, documentos e testes funcionais. Os agentes Kiro ajudam os desenvolvedores a resolver problemas desafiadores e automatizar tarefas como gerar documentação e testes unitários.
+ [O Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) é um assistente conversacional generativo baseado em IA que pode ajudar você a entender, criar, estender e operar aplicativos. AWS
**Outras ferramentas**
+ O [Bandit](https://bandit.readthedocs.io/en/latest/) é uma ferramenta especializada de scanner de segurança em Python. Ele detecta problemas comuns de segurança do Python, como funções inseguras, segredos codificados e vulnerabilidades de injeção. O Bandit fornece classificações detalhadas de confiança e severidade.
+ O [Checkov](https://github.com/bridgecrewio/checkov) é uma ferramenta estática de análise de código que verifica o IaC em busca de configurações incorretas de segurança e conformidade. Além disso, o Checkov detecta violações de conformidade e as melhores práticas de segurança.
+ [O Cline](https://cline.bot/) é um assistente de codificação com inteligência artificial que é executado no VS Code.
+ [Loguru](https://loguru.readthedocs.io/en/stable/) é uma biblioteca de validação de dados para Python.
+ O [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) é uma estrutura de código aberto para criar ferramentas de desenvolvimento assistidas por IA.
+ [Pydantic](https://docs.pydantic.dev/latest/) é uma biblioteca de validação de dados para Python.
+ [O Semgrep](https://semgrep.dev/docs/introduction) analisa o código-fonte em busca de vulnerabilidades e bugs de segurança. Ele suporta várias linguagens de programação. O Semgrep usa conjuntos de regras focados na segurança para uma análise abrangente. Ele fornece classificações detalhadas de confiança e severidade.
**Repositório de código**
O código desse padrão está disponível no repositório GitHub [MCP Security Scanner: Real-Time Protection for AI Code Assistants](https://github.com/aws-samples/sample-mcp-security-scanner). O repositório inclui a implementação do servidor MCP, detalhes sobre a configuração do MCP para Kiro, Amazon Q Developer, Cline e outros, exemplos de configuração e utilitários de teste.
A estrutura do repositório inclui:
+ `security_scanner_mcp_server/`- Implementação do servidor principal
+ `docs/`- Documentação e materiais de demonstração
+ `tests/`- Arquivos de teste
+ `mcp-config-example.json`- Exemplo de configuração MCP
+ `requirements.txt`- Dependências do projeto
## Práticas recomendadas
**Implementação da digitalização**
+ Analise as descobertas de segurança para validar e priorizar os problemas.
+ Mantenha as ferramentas de digitalização (Checkov, Semgrep e Bandit) atualizadas para as versões mais recentes.
+ Use a ferramenta de segurança MCP desse padrão em conjunto com outras medidas e ferramentas de segurança.
+ Atualize os conjuntos de regras e políticas de segurança regularmente.
**Gerenciamento de configuração**
+ Use os arquivos de configuração do MCP na fonte oficial de controle de versão.
+ Documente regras e configurações personalizadas.
**Integration**
+ Integre a verificação de segurança no início do ciclo de desenvolvimento.
+ Configure a digitalização automatizada em ganchos de pré-confirmação ou em pipelines de integração contínua e implantação contínua (CI/CD).
+ Configure os limites de severidade apropriados para seu ambiente.
+ Estabeleça procedimentos claros para lidar com as descobertas de segurança.
**Considerações operacionais**
+ Monitore o desempenho da digitalização e o uso de recursos.
+ Implemente o tratamento e o registro de erros adequados.
+ Mantenha a documentação das configurações personalizadas.
+ Estabeleça um processo para revisar e atualizar as regras de segurança.
Além disso, lembre-se das seguintes práticas recomendadas:
+ Sempre valide as descobertas de segurança em seu contexto específico.
+ Mantenha as ferramentas e dependências de segurança atualizadas.
+ Use várias ferramentas de segurança para uma cobertura abrangente.
+ Siga as melhores práticas de segurança em seu processo de desenvolvimento.
## Épicos
### (Usuários do Kiro) Configurar o servidor do scanner de segurança MCP
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Defina as configurações do MCP. | Você pode editar os arquivos de configuração no Kiro (Opção 1) localizando manualmente os arquivos de configuração ou (Opção 2) usando o Kiro IDE.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": []
}
}
} | Desenvolvedor de aplicativos |
### (Usuários do Amazon Q Developer) Configurar o servidor do scanner de segurança MCP
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Defina as configurações do MCP. | Para definir as configurações de MCP manualmente, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
} | Desenvolvedor de aplicativos |
### (Usuários do Cline) Configurar o servidor do scanner de segurança MCP
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Defina as configurações do MCP. | Para definir as configurações de MCP manualmente, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": []
}
}
} | Desenvolvedor de aplicativos |
### Exemplo de análise de código usando Python e Bandit
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Realizar a análise do código. | Para realizar a análise de código usando Python e Bandit, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Desenvolvedor de aplicativos |
### Exemplo de análise de código usando Terraform e Checkov
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Realizar a análise do código. | Para realizar a análise de código usando o Terraform e o Checkov, use as seguintes etapas:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Desenvolvedor de aplicativos |
### Exemplo de recursos avançados de digitalização
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Execute a digitalização direcionada. | Veja a seguir exemplos de solicitações que você pode usar para realizar uma verificação direcionada:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Desenvolvedor de aplicativos |
| Use a varredura de segurança com geração de código. | Para resolver descobertas de segurança usando loops de geração de código, use as etapas a seguir (este exemplo usa o Kiro como assistente de codificação):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Desenvolvedor de aplicativos |
## Solução de problemas
| Problema | Solução |
| --- | --- |
| Problemas de configuração do ambiente | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Problemas com o scanner | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Problemas de integração | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Suporte adicional | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
## Recursos relacionados
**AWS documentação**
+ [Infraestrutura como código](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/infrastructure-as-code.html) (AWS Whitepaper *Introdução à DevOps on*) AWS
**Outros AWS recursos**
+ [Práticas recomendadas de segurança, identidade e conformidade](https://aws.amazon.com/architecture/security-identity-compliance/)
**Outros recursos**
+ [Documentação do Bandit](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Documentação Checkov](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Documentação do Model Context Protocol (MCP)](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Práticas de codificação segura da OWASP](https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/) (site da Fundação OWASP)
+ [Documentação Semgrep](https://aws.amazon.com/architecture/security-identity-compliance/)
## Mais informações
**Exemplo de configuração MCP com aprovação automática ativada**
Sem `autoApprove` configurado, o usuário deve conceder aprovação para enviar o código ao servidor de segurança MCP para digitalização. Quando `autoApprove` configurado, o assistente de código pode invocar as ferramentas sem a aprovação do usuário. Essas ferramentas são executadas localmente na máquina, nenhum dado é enviado e somente uma varredura de código é executada.
A configuração a seguir permite a execução automática de todas as funções de verificação de segurança:
```
{
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": [
"scan_with_checkov",
"scan_with_semgrep",
"scan_with_bandit",
"get_supported_formats"
]
}
}
}
```
Para ativar o registro de depuração, `"FASTMCP_LOG_LEVEL"` defina `"DEBUG"` como.
**Formatos de arquivo suportados pelas ferramentas de verificação de segurança**
Cada ferramenta de verificação de segurança dessa solução oferece suporte aos seguintes formatos de arquivo:
*Checkov (IAc)*
+ Terraform — .tf, .tfvars, .tfstate
+ CloudFormation — .yaml, .yml, .json, .template
+ Kubernetes — .yaml, .yml
+ Dockerfile — Dockerfile
+ ARM — .json (Gerenciador de Recursos do Azure)
+ Bíceps — .bíceps
+ Sem servidor — .yml, .yaml
+ Capacete — .yaml, .yml, .tpl
+ GitHub Ações — .yml, .yaml
+ GitLab\$1ci — .yml, .yaml
+ Ansible — .yml, .yaml
*Semgrep (Código fonte)*
+ Python — .py
+ JavaScript — .js
+ TypeScript — .ts
+ Java — .java
+ Vá — .go
+ C — c.
+ C\$1\$1 — .cpp
+ C\$1 — .cs
+ Rubi — .rb
+ PHP — .php
+ Scala — .scala
+ Kotlin — .kt
+ Ferrugem — .rs
*Bandit (somente Python)*
+ Python — .py
**Demos**
Para digitalização de código, experimente os seguintes exemplos de solicitações com seu assistente de IA:
+ “Examine o script atual e me diga os resultados.”
+ “Examine as linhas 20—60 e me diga os resultados.”
+ “Examine esse recurso de tabela do Amazon DynamoDB e me diga o resultado.”
Para obter mais informações, consulte esta [demonstração de digitalização de código](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_scan.gif) no GitHub repositório desse padrão.
Para gerar um código seguro, experimente os seguintes exemplos de prompts:
+ “Gere uma configuração do Terraform para criar uma tabela do DynamoDB com criptografia ativada e escaneá-la em busca de problemas de segurança.”
+ “Crie uma função Python Lambda que grava no DynamoDB e verifique se há vulnerabilidades.”
+ “Gere um CloudFormation modelo para um bucket S3 com as configurações de segurança adequadas e verifique se ele passa nas verificações de segurança.”
+ “Escreva um script em Python para consultar o DynamoDB com paginação e verifique as melhores práticas de segurança.”
+ “Crie um manifesto de implantação do Kubernetes para um microsserviço com reforço de segurança e valide-o.”
Para obter mais informações, consulte esta demonstração de [geração de código com verificação de segurança](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_generation.gif) no GitHub repositório desse padrão.
# Desenvolva assistentes avançados baseados em bate-papo com IA generativa usando RAG e prompting ReAct
*Praveen Kumar Jeyarajan, Shuai Cao, Noah Hamilton, Kiowa Jackson, Jundong Qiao e Kara Yang, Amazon Web Services*
## Resumo
As corporações costumam ter 70% de seus dados presos em sistemas isolados. Você pode usar assistentes baseados em chat com IA generativa para descobrir insights e relacionamentos entre esses silos de dados por meio de interações em linguagem natural. Para tirar o máximo proveito da IA generativa, os resultados devem ser confiáveis, precisos e incluir os dados corporativos disponíveis. Assistentes baseados em chat eficientes dependem do seguinte:
+ Modelos de IA generativa (como Anthropic Claude 2)
+ Vetorização da fonte de dados
+ Técnicas avançadas de raciocínio, como a [ReAct estrutura](https://www.promptingguide.ai/techniques/react), para estimular o modelo
Este padrão fornece abordagens de recuperação de dados com base em fontes de dados como buckets do Amazon Simple Storage Service (Amazon S3), AWS Glue e Amazon Relational Database Service (Amazon RDS). O valor é obtido desses dados intercalando a [Geração Aumentada de Recuperação (RAG](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)) com métodos. chain-of-thought Os resultados apoiam conversas complexas com assistentes baseados em chat que se baseiam na totalidade dos dados armazenados de sua corporação.
Esse padrão usa SageMaker manuais e tabelas de dados de preços da Amazon como exemplo para explorar os recursos de um assistente generativo baseado em bate-papo com IA. Você criará um assistente baseado em bate-papo que ajudará os clientes a avaliar o SageMaker serviço respondendo a perguntas sobre preços e recursos do serviço. A solução usa uma biblioteca Streamlit para criar o aplicativo front-end e a LangChain estrutura para desenvolver o back-end do aplicativo alimentado por um modelo de linguagem grande (LLM).
As consultas ao assistente baseado em chat são atendidas com uma classificação inicial de intenção para encaminhamento para um dos três fluxos de trabalho possíveis. O fluxo de trabalho mais sofisticado combina orientação consultiva geral com análises complexas de preços. Você pode adaptar o padrão para se adequar aos casos de uso empresarial, corporativo e industrial.
## Pré-requisitos e limitações
**Pré-requisitos **
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) instalada e configurada
+ [Kit de ferramentas do AWS Cloud Development Kit (AWS CDK) 2.114.1 ou posterior](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) instalado e configurado
+ Familiaridade básica com o Python e o AWS CDK
+ [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) instalado
+ [Docker](https://docs.docker.com/get-docker/) instalado
+ [Python 3.11 ou posterior](https://www.python.org/downloads/) instalado e configurado (para obter mais informações, consulte a seção [Ferramentas](#develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting-tools))
+ Bootstrap de uma [conta da AWS ativa](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-creating.html) usando o [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)
+ [Acesso aos modelos](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access) Amazon Titan e Anthropic Claude habilitado no serviço Amazon Bedrock
+ [Credenciais de segurança da AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html), inclusive `AWS_ACCESS_KEY_ID`, configuradas corretamente em seu ambiente de terminal
**Limitações**
+ LangChain não suporta todos os LLM para streaming. Os modelos Anthropic Claude são suportados, mas os modelos do AI21 Labs não.
+ Essa solução é implantada em uma única conta da AWS.
+ Essa solução pode ser implantada somente nas regiões da AWS onde o Amazon Bedrock e o Amazon Kendra estão disponíveis. Para obter informações sobre disponibilidade, consulte a documentação do [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html#bedrock-regions) e do [Amazon Kendra](https://docs.aws.amazon.com/general/latest/gr/kendra.html).
**Versões do produto**
+ Python versão 3.11 ou posterior
+ Streamlit versão 1.30.0 ou posterior.
+ Streamlit-chat versão 0.1.1 ou posterior
+ LangChain versão 0.1.12 ou posterior
+ AWS CDK versão 2.132.1 ou posterior
## Arquitetura
**Pilha de tecnologias de destino**
+ Amazon Athena
+ Amazon Bedrock
+ Amazon Elastic Container Service (Amazon ECS)
+ AWS Glue
+ AWS Lambda
+ Amazon S3
+ Amazon Kendra
+ Elastic Load Balancing
**Arquitetura de destino**
O código do AWS CDK implantará todos os recursos necessários para configurar a aplicação do assistente baseado em chat em uma conta da AWS. O aplicativo assistente baseado em bate-papo mostrado no diagrama a seguir foi projetado para responder às consultas SageMaker relacionadas dos usuários. Os usuários se conectam por meio de um Application Load Balancer a uma VPC que contém um cluster do Amazon ECS que hospeda a aplicação Streamlit. Uma função do Lambda de orquestração se conecta à aplicação. As fontes de dados do bucket do S3 fornecem dados para a função do Lambda por meio do Amazon Kendra e do AWS Glue. A função do Lambda se conecta ao Amazon Bedrock para responder consultas (perguntas) de usuários de assistentes baseados em chat.
![\[Diagrama de arquitetura.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/4e5856cf-9489-41f8-a411-e3b8d8a50748.png)
1. A função do Lambda de orquestração envia a solicitação de prompt do LLM para o modelo do Amazon Bedrock (Claude 2).
1. O Amazon Bedrock envia a resposta do LLM de volta para a função do Lambda de orquestração.
**Fluxo lógico dentro da função do Lambda de orquestração**
Quando os usuários fazem uma pergunta por meio da aplicação Streamlit, ela invoca diretamente a função do Lambda de orquestração. O diagrama a seguir mostra o fluxo lógico quando a função do Lambda é invocada.
![\[Diagrama de arquitetura.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/70ae4736-06a6-4d3a-903a-edc5c10d78a0.png)
+ Etapa 1: a entrada `query` (pergunta) é classificada em uma das três intenções:
+ Perguntas gerais de SageMaker orientação
+ Perguntas gerais SageMaker sobre preços (treinamento/inferência)
+ Perguntas complexas relacionadas a preços SageMaker e preços
+ Etapa 2: a entrada `query` inicia um dos três serviços:
+ `RAG Retrieval service`, que recupera o contexto relevante do banco de dados de vetores do [Amazon Kendra](https://aws.amazon.com/kendra/) e chama o LLM por meio do [Amazon Bedrock](https://aws.amazon.com/bedrock/) para resumir o contexto recuperado como resposta.
+ `Database Query service`, que usa o LLM, os metadados do banco de dados e as linhas de exemplo das tabelas relevantes para converter a entrada `query` em uma consulta SQL. O serviço Database Query executa a consulta SQL no banco de dados de SageMaker preços por meio do [Amazon Athena](https://aws.amazon.com/athena/) e resume os resultados da consulta como resposta.
+ `In-context ReACT Agent service`, que divide a entrada `query` em várias etapas antes de fornecer uma resposta. O agente usa o `RAG Retrieval service` e o `Database Query service` como ferramentas para recuperar informações relevantes durante o processo de raciocínio. Depois que os processos de raciocínio e ações são concluídos, o agente gera o resultado final como resposta.
+ Etapa 3: a resposta da função do Lambda de orquestração é enviada à aplicação Streamlit como saída.
## Ferramentas
**Serviços da AWS**
+ O [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) é um serviço de consultas interativas que permite analisar dados diretamente no Amazon Simple Storage Service (Amazon S3) usando SQL padrão.
+ [O Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) é um serviço totalmente gerenciado que disponibiliza modelos básicos de alto desempenho (FMs) das principais startups de IA e da Amazon para seu uso por meio de uma API unificada.
+ O [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura da Nuvem AWS em código.
+ A [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando.
+ O [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) é um serviço de gerenciamento de contêineres escalável e rápido que facilita a execução, a interrupção e o gerenciamento de contêineres em um cluster.
+ O [AWS Glue](https://docs.aws.amazon.com/glue/) é um serviço de extração, transformação e carregamento (ETL) totalmente gerenciado. Ele ajuda você a categorizar de forma confiável, limpar, enriquecer e mover dados de forma confiável entre armazenamento de dados e fluxos de dados. Esse padrão usa um crawler do AWS Glue e uma tabela do Catálogo de Dados do AWS Glue.
+ O [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) é um serviço de pesquisa inteligente que usa processamento de linguagem natural e algoritmos avançados de machine learning para retornar respostas específicas às perguntas de pesquisa de seus dados.
+ O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda você a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
+ O [Elastic Load Balancing (ELB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribui o tráfego de entrada de aplicativos ou de rede em vários destinos. Por exemplo, é possível distribuir o tráfego entre instâncias, contêineres e endereços IP do Amazon Elastic Compute Cloud (Amazon EC2) em uma ou mais Zonas de disponibilidade.
**Repositório de código**
O código desse padrão está disponível no GitHub [genai-bedrock-chatbot](https://github.com/awslabs/genai-bedrock-chatbot)repositório.
O repositório de código contém os seguintes arquivos e pastas:
+ Pasta `assets`: os ativos estáticos, o diagrama de arquitetura e o conjunto de dados público
+ Pasta `code/lambda-container`: o código Python que é executado na função do Lambda
+ Pasta `code/streamlit-app`: o código Python que é executado como imagem de contêiner no Amazon ECS
+ Pasta `tests`: os arquivos Python que são executados para teste de unidade dos constructos do AWS CDK
+ `code/code_stack.py`: os arquivos Python de constructo do AWS CDK usados para criar os recursos da AWS
+ `app.py`: os arquivos Python de pilha do AWS CDK usados para implantar recursos da AWS na conta da AWS de destino
+ `requirements.txt`: a lista de todas as dependências do Python que devem ser instaladas para o AWS CDK
+ `requirements-dev.txt`: a lista de todas as dependências do Python que devem ser instaladas para que o AWS CDK execute o pacote de teste de unidade
+ `cdk.json`: o arquivo de entrada para fornecer os valores necessários para gerar recursos
|
|
| Observação: o código do AWS CDK usa [constructos L3 (camada 3)](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html) e [políticas do AWS Identity and Access Management (IAM) gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) para implantar a solução. |
| --- |
## Práticas recomendadas
+ O exemplo de código fornecido aqui é apenas para uma demonstração proof-of-concept (PoC) ou piloto. Se você pretende implantar o código para produção, certifique-se de seguir as seguintes práticas recomendadas:
+ [Os logs de acesso do Amazon S3 estão habilitados](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html).
+ [O VPC Flow Logs está habilitado](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html).
+ O índice do [Amazon Kendra Enterprise Edition](https://docs.aws.amazon.com/whitepapers/latest/how-aws-pricing-works/amazon-kendra.html) está habilitado.
+ Configure o monitoramento e o alerta para a função do Lambda. Para obter mais informações, consulte [Monitorar e solucionar problemas de funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Para obter as melhores práticas gerais ao trabalhar com funções do Lambda, consulte a [documentação da AWS](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Épicos
### Configurar credenciais da AWS na sua máquina local
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Exporte variáveis para a conta e a região da AWS em que a pilha será implantada. | Para fornecer credenciais da AWS para o AWS CDK usando variáveis de ambiente, execute os seguintes comandos.export CDK_DEFAULT_ACCOUNT=<12 Digit AWS Account Number>
export CDK_DEFAULT_REGION=
| DevOps engenheiro, AWS DevOps |
| Configurar o perfil da AWS CLI. | Para configurar o perfil da AWS CLI para a conta, siga as instruções na [documentação da AWS](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/keys-profiles-credentials.html). | DevOps engenheiro, AWS DevOps |
### Configure o ambiente.
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Clone o repositório na sua máquina local. | Para clonar o repositório, execute o comando a seguir no seu terminal.git clone https://github.com/awslabs/genai-bedrock-chatbot.git
| DevOps engenheiro, AWS DevOps |
| Configurar o ambiente virtual Python e instalar as dependências necessárias. | Para ativar o ambiente virtual do Python, execute os comandos a seguir.cd genai-bedrock-chatbot
python3 -m venv .venv
source .venv/bin/activate
Para configurar as dependências necessárias, execute o comando a seguir.pip3 install -r requirements.txt
| DevOps engenheiro, AWS DevOps |
| Configure o ambiente do AWS CDK e sintetize o código do AWS CDK. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps engenheiro, AWS DevOps |
### Configurar e implantar a aplicação do assistente baseado em chat
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Provisione o acesso ao modelo Claude. | Para habilitar o acesso ao modelo Anthropic Claude para sua conta da AWS, siga as instruções na [documentação do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access). | AWS DevOps |
| Implante recursos na conta. | Para implantar recursos na conta da AWS usando o AWS CDK, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)Após a implantação bem-sucedida, você pode acessar o aplicativo assistente baseado em bate-papo usando a URL fornecida na seção CloudFormation **Saídas**. | AWS DevOps, DevOps engenheiro |
| Execute o AWS Glue Crawler e crie a tabela do Data Catalog. | Um [AWS Glue Crawler](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) é usado para manter o esquema de dados dinâmico. A solução cria e atualiza partições na [tabela do Catálogo de Dados do AWS Glue](https://docs.aws.amazon.com/athena/latest/ug/querying-glue-catalog.html) executando o crawler sob demanda. Depois que os arquivos do conjunto de dados CSV forem copiados no bucket do S3, execute o crawler do AWS Glue e crie o esquema da tabela do Catálogo de Dados para teste:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)O código do AWS CDK configura o crawler do AWS Glue para ser executado sob demanda, mas você também pode [programá-lo](https://docs.aws.amazon.com/glue/latest/dg/schedule-crawler.html) para ser executado periodicamente. | DevOps engenheiro, AWS DevOps |
| Inicie a indexação de documentos. | Depois que os arquivos forem copiados no bucket do S3, use o Amazon Kendra para rastreá-los e indexá-los:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)O código do AWS CDK configura a sincronização do índice do Amazon Kendra para ser executada sob demanda, mas você também pode executá-la periodicamente usando o [parâmetro Schedule](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html#cron). | AWS DevOps, DevOps engenheiro |
### Limpe todos os recursos da AWS na solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Remova os recursos da AWS. | Após testar a solução, limpe os recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps engenheiro, AWS DevOps |
## Solução de problemas
| Problema | Solução |
| --- | --- |
| O AWS CDK retorna erros. | Para obter ajuda com problemas do AWS CDK, consulte [Solução de problemas comuns do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html). |
## Recursos relacionados
+ Amazon Bedrock:
+ [Acesso ao modelo](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parâmetros de inferência para modelos de fundação](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Criar funções do Lambda com Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Começar a usar o AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Trabalhar com o AWS CDK no Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Criador de aplicações de IA generativa na AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
+ [LangChain documentação](https://python.langchain.com/docs/get_started/introduction)
+ [Documentação do Streamlit](https://docs.streamlit.io/)
## Mais informações
**Comandos do AWS CDK**
Ao trabalhar com o AWS CDK, lembre-se dos seguintes comandos úteis:
+ Lista todas as pilhas no aplicativo
```
cdk ls
```
+ Emite o modelo sintetizado da AWS CloudFormation
```
cdk synth
```
+ Implanta a pilha na sua conta e região padrão da AWS
```
cdk deploy
```
+ Compara a pilha implantada com o estado atual
```
cdk diff
```
+ Abre a documentação do AWS CDK
```
cdk docs
```
+ Exclui a CloudFormation pilha e remove os recursos implantados da AWS
```
cdk destroy
```
# Desenvolvimento de um assistente totalmente automatizado baseado em chat usando os agentes e as bases de conhecimento do Amazon Bedrock
*Jundong Qiao, Shuai Cao, Noah Hamilton, Kiowa Jackson, Praveen Kumar Jeyarajan e Kara Yang, Amazon Web Services*
## Resumo
Muitas organizações enfrentam desafios ao criar um assistente baseado em chat capaz de orquestrar diversas fontes de dados para fornecer respostas completas. Este padrão apresenta uma solução para o desenvolvimento de um assistente de chat capaz de responder a consultas tanto de documentação quanto de bancos de dados, com uma implantação simples.
Começando com o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html), esse serviço de inteligência artificial generativa (IA) totalmente gerenciado fornece uma ampla variedade de modelos básicos avançados (FMs). Esse serviço permite a criação de aplicações de IA generativa de forma eficiente, mantendo grande atenção à privacidade e à segurança. No contexto da recuperação de documentação, o recurso de [geração aumentada via recuperação (RAG)](https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-customize-rag.html) é fundamental. Ele emprega as [bases de conhecimento](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) para complementar os prompts dos FMs com informações contextualmente relevantes provenientes de fontes externas. Um índice [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) serve como banco de dados vetorial por trás das bases de conhecimento do Amazon Bedrock. A integração é otimizada com o uso de uma engenharia de prompts precisa, a fim de minimizar imprecisões e garantir que as respostas estejam fundamentadas em documentação factual. Para consultas de banco FMs de dados, o Amazon Bedrock transforma consultas textuais em consultas SQL estruturadas, incorporando parâmetros específicos. Isso permite a recuperação precisa de dados de bancos de dados gerenciados por [AWS Glue bancos](https://docs.aws.amazon.com/glue/latest/dg/define-database.html) de dados. O [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) é usado para executar essas consultas.
Quando se trata de consultas mais elaboradas, obter respostas completas requer informações provenientes tanto da documentação quanto de bancos de dados. Os [Agentes para Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) são um recurso de IA generativa que auxilia na criação de agentes autônomos capazes de compreender tarefas complexas e dividí-las em tarefas mais simples para orquestração. A combinação dos insights obtidos a partir das tarefas simplificadas, facilitada pelos agentes autônomos do Amazon Bedrock, otimiza a síntese de informações, resultando em respostas mais completas e detalhadas. Este padrão demonstra como desenvolver um assistente baseado em chat usando o Amazon Bedrock e os serviços e recursos de IA generativa relacionados em uma solução automatizada.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Um ativo Conta da AWS
+ Docker, [instalado](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK), [instalado](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) e [inicializado no ou](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) `us-east-1` `us-west-2` Regiões da AWS
+ AWS CDK [Kit de ferramentas versão 2.114.1 ou posterior, instalado](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ AWS Command Line Interface (AWS CLI), [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [configurado](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ Python, versão 3.11 ou versões posteriores, [instalado](https://www.python.org/downloads/)
+ No Amazon Bedrock, [habilite o acesso](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html) a Claude 2, Claude 2.1, Claude Instant e Titan Embeddings G1 – Text
**Limitações**
+ Essa solução é implantada em um único Conta da AWS.
+ Essa solução só pode ser implantada Regiões da AWS onde o Amazon Bedrock e o Amazon OpenSearch Serverless são suportados. Para obter mais informações, consulte a documentação do [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) e do [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html#serverless-regions).
**Versões do produto**
+ Llama-index, na versão 0.10.6 ou em versões posteriores
+ Sqlalchemy, na versão 2.0.23 ou em versões posteriores
+ OpenSearch-py, na versão 2.4.2 ou em versões posteriores
+ Requests\$1aws4auth, versão 1.2.3 ou em versões posteriores
+ AWS SDK para Python (Boto3) versão 1.34.57 ou posterior
## Arquitetura
**Pilha de tecnologias de destino**
[AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)É uma estrutura de desenvolvimento de software de código aberto para definir a infraestrutura de nuvem em código e provisioná-la por meio dela. AWS CloudFormation A AWS CDK pilha usada nesse padrão implanta os seguintes recursos: AWS
+ AWS Key Management Service (AWS KMS)
+ Amazon Simple Storage Service (Amazon S3)
+ AWS Glue Data Catalog, para o componente de AWS Glue banco de dados
+ AWS Lambda
+ AWS Identity and Access Management (IAM)
+ Amazon sem OpenSearch servidor
+ Amazon Elastic Container Registry (Amazon ECR)
+ Amazon Elastic Container Service (Amazon ECS)
+ AWS Fargate
+ Amazon Virtual Private Cloud (Amazon VPC)
+ [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)
**Arquitetura de destino**
![\[Diagrama da arquitetura usando uma base de conhecimento e um agente do Amazon Bedrock.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/15372718-3a5d-4918-9cfa-422c455f288d/images/ff19152e-0bb6-4758-a6dd-4f6140e55113.png)
O diagrama mostra uma configuração abrangente AWS nativa da nuvem em uma única Região da AWS, usando várias. Serviços da AWS A interface primária do assistente baseado em chat é uma aplicação [Streamlit](https://docs.streamlit.io/) hospedada em um cluster do Amazon ECS. Um [Application Load Balancer](https://aws.amazon.com/elasticloadbalancing/application-load-balancer/) gerencia a acessibilidade. As consultas realizadas por meio desta interface acionam a função do Lambda `Invocation`, que posteriormente interage com os agentes para Amazon Bedrock. Este agente responde às consultas dos usuários consultando as bases de conhecimento para Amazon Bedrock ou invocando uma função do Lambda `Agent executor`. A função aciona um conjunto de ações associadas ao agente, de acordo com um esquema de API previamente definido. As bases de conhecimento do Amazon Bedrock usam um índice OpenSearch Serverless como base de banco de dados vetorial. Além disso, a `Agent executor` função gera consultas SQL que são executadas no AWS Glue banco de dados por meio do Amazon Athena.
## Ferramentas
**Serviços da AWS**
+ O [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) é um serviço de consultas interativas que ajuda a análise de dados diretamente no Amazon Simple Storage Service (Amazon S3) usando SQL padrão.
+ [O Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) é um serviço totalmente gerenciado que disponibiliza modelos básicos de alto desempenho (FMs) das principais startups de IA e da Amazon para seu uso por meio de uma API unificada.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura de AWS nuvem em código.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando.
+ O [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) é um serviço de gerenciamento de contêineres escalável e rápido que facilita a execução, a interrupção e o gerenciamento de contêineres em um cluster.
+ O [Elastic Load Balancing (ELB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribui o tráfego de entrada de aplicativos ou de rede em vários destinos. Por exemplo, é possível distribuir o tráfego entre instâncias, contêineres e endereços IP do Amazon Elastic Compute Cloud (Amazon EC2) em uma ou mais Zonas de disponibilidade.
+ O [AWS Glue](https://docs.aws.amazon.com/glue/) é um serviço totalmente gerenciado de extração, transformação e carregamento (ETL). Ele ajuda você a categorizar de forma confiável, limpar, enriquecer e mover dados de forma confiável entre armazenamento de dados e fluxos de dados. Esse padrão usa um AWS Glue rastreador e uma AWS Glue Data Catalog tabela.
+ O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado.
+ [O Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) é uma configuração sem servidor sob demanda para o Amazon Service. OpenSearch Nesse padrão, um índice OpenSearch sem servidor serve como um banco de dados vetorial para as bases de conhecimento do Amazon Bedrock.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
**Outras ferramentas**
+ O [Streamlit](https://docs.streamlit.io/) é uma estrutura de código aberto do Python para desenvolvimento de aplicações de dados.
**Repositório de código**
O código desse padrão está disponível no GitHub [genai-bedrock-agent-chatbot](https://github.com/awslabs/genai-bedrock-agent-chatbot/)repositório. O repositório de código contém os seguintes arquivos e pastas:
+ Pasta `assets`: os recursos estáticos, como o diagrama da arquitetura e o conjunto de dados público.
+ Pasta `code/lambdas/action-lambda`: o código Python da função do Lambda que atua como uma ação para o agente do Amazon Bedrock.
+ `code/lambdas/create-index-lambda`pasta — O código Python para a função Lambda que cria o índice Serverless. OpenSearch
+ Pasta `code/lambdas/invoke-lambda`: o código Python da função do Lambda que invoca o agente do Amazon Bedrock, chamado diretamente pela aplicação Streamlit.
+ `code/lambdas/update-lambda`pasta — O código Python para a função Lambda que atualiza ou exclui recursos depois que os recursos são implantados por meio do AWS . AWS CDK
+ `code/layers/boto3_layer`pasta — A AWS CDK pilha que cria uma camada de Boto3 que é compartilhada entre todas as funções do Lambda.
+ `code/layers/opensearch_layer`pasta — A AWS CDK pilha que cria uma camada OpenSearch sem servidor que instala todas as dependências para criar o índice.
+ `code/streamlit-app`pasta — O código Python que é executado como imagem do contêiner no Amazon ECS.
+ `code/code_stack.py`— A AWS CDK construção de arquivos Python que criam AWS recursos.
+ `app.py`— A AWS CDK pilha de arquivos Python que AWS implantam recursos na conta de destino. AWS
+ `requirements.txt`— A lista de todas as dependências do Python que devem ser instaladas para o. AWS CDK
+ `cdk.json`: o arquivo de entrada que fornece os valores necessários para criar recursos. Além disso, nos campos de `context/config`, você pode personalizar a solução conforme necessário. Para obter mais informações sobre a personalização, consulte a seção [Informações adicionais](#develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases-additional).
## Práticas recomendadas
+ O exemplo de código fornecido aqui é apenas para fins proof-of-concept (PoC) ou piloto. Se você pretende implantar o código para produção, certifique-se de seguir as seguintes práticas recomendadas:
+ Habilitar o [registro em log de acesso do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
+ Habilitar os [logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)
+ Configure o monitoramento e a geração de alertas para as funções do Lambda. Para obter mais informações, consulte [Monitorar e solucionar problemas de funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Para ver as melhores práticas, consulte as [Melhores práticas para trabalhar com AWS Lambda funções](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Épicos
### Configure AWS as credenciais em sua estação de trabalho local
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Exporte variáveis para a conta e para a região. | Para fornecer AWS credenciais para o AWS CDK usando variáveis de ambiente, execute os comandos a seguir.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps engenheiro |
| Configure o perfil AWS CLI nomeado. | Para configurar o perfil AWS CLI nomeado para a conta, siga as instruções em [Configuração e configurações do arquivo de credenciais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). | AWS DevOps, DevOps engenheiro |
### Configure o ambiente.
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Clone o repositório na sua estação de trabalho local. | Para clonar o repositório, execute o comando a seguir no seu terminal.git clone https://github.com/awslabs/genai-bedrock-agent-chatbot.git
| DevOps engenheiro, AWS DevOps |
| Configure o ambiente virtual do Python. | Para ativar o ambiente virtual do Python, execute os comandos a seguir.cd genai-bedrock-agent-chatbot
python3 -m venv .venv
source .venv/bin/activate
Para configurar as dependências necessárias, execute o comando a seguir.pip3 install -r requirements.txt
| DevOps engenheiro, AWS DevOps |
| Configure o AWS CDK ambiente. | Para converter o código em um AWS CloudFormation modelo, execute o comando`cdk synth`. | AWS DevOps, DevOps engenheiro |
### Configuração e implantação da aplicação
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Implante recursos na conta. | Para implantar recursos no Conta da AWS usando o AWS CDK, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases.html)Após a implantação bem-sucedida, você pode acessar o aplicativo assistente baseado em bate-papo usando a URL fornecida na guia **Saídas** no console. CloudFormation | DevOps engenheiro, AWS DevOps |
### Limpe todos os AWS recursos da solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Remova os AWS recursos. | Após testar a solução, para limpar os recursos, execute o comando `cdk destroy`. | AWS DevOps, DevOps engenheiro |
## Recursos relacionados
**AWS documentação**
+ Recursos do Amazon Bedrock:
+ [Acesso ao modelo](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parâmetros de inferência para modelos de fundação](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Agentes do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html)
+ [Bases de Conhecimento para Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)
+ [Criar funções do Lambda com Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ AWS CDK recursos:
+ [Comece com o AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Solução de AWS CDK problemas comuns](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Trabalhando com o AWS CDK em Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Construtor de aplicativos de IA generativa em AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Outros AWS recursos**
+ [Mecanismo vetorial para Amazon OpenSearch Serverless](https://aws.amazon.com/opensearch-service/serverless-vector-engine/)
**Outros recursos**
+ [LlamaIndex documentação](https://docs.llamaindex.ai/en/stable/)
+ [Documentação do Streamlit](https://docs.streamlit.io/)
## Mais informações
**Personalização do assistente baseado em chat com seus próprios dados**
Para integrar dados personalizados na implantação da solução, siga estas diretrizes estruturadas. Estas etapas foram elaboradas para garantir um processo de integração contínuo e eficiente, permitindo que você implante a solução de forma eficaz com seus dados personalizados.
*Para integração de dados da base de conhecimento*
**Preparação de dados**
1. Localize o diretório `assets/knowledgebase_data_source/`.
1. Coloque seu conjunto de dados dentro desta pasta.
**Ajustes de configuração**
1. Abra o arquivo `cdk.json`.
1. Acesse o campo `context/configure/paths/knowledgebase_file_name` e, em seguida, atualize-o conforme necessário.
1. Acesse o campo `bedrock_instructions/knowledgebase_instruction` e, em seguida, atualize-o para refletir com precisão as particularidades e o contexto do seu novo conjunto de dados.
*Para integração de dados estruturados*
**Organização dos dados**
1. No diretório `assets/data_query_data_source/`, crie uma subpasta, como `tabular_data`.
1. Coloque seu conjunto de dados estruturado (em um dos formatos aceitos, incluindo CSV, JSON, ORC e Parquet) nesta subpasta recém-criada.
1. Se você estiver estabelecendo conexão com um banco de dados existente, atualize a função `create_sql_engine()` no arquivo `code/lambda/action-lambda/build_query_engine.py` para se conectar ao banco de dados.
**Atualizações de configuração e de código**
1. No arquivo `cdk.json`, atualize o campo `context/configure/paths/athena_table_data_prefix` para alinhar com o novo caminho dos dados.
1. Revise `code/lambda/action-lambda/dynamic_examples.csv` incorporando novos text-to-SQL exemplos que correspondam ao seu conjunto de dados.
1. Analise o arquivo `code/lambda/action-lambda/prompt_templates.py` para refletir os atributos do seu conjunto de dados estruturado.
1. No arquivo `cdk.json`, atualize o campo `context/configure/bedrock_instructions/action_group_description` para explicar o propósito e a funcionalidade da função do Lambda `Action group`.
1. No arquivo `assets/agent_api_schema/artifacts_schema.json`, explique as novas funcionalidades da função do Lambda `Action group`.
*Atualização geral*
No arquivo `cdk.json`, na seção `context/configure/bedrock_instructions/agent_instruction`, forneça uma descrição detalhada da funcionalidade pretendida e do propósito de design do agente do Amazon Bedrock, considerando os novos dados integrados.
# Documentação do conhecimento institucional usando entradas de voz por meio do Amazon Bedrock e do Amazon Transcribe
*Praveen Kumar Jeyarajan, Jundong Qiao, Rajiv Upadhyay e Megan Wu, Amazon Web Services*
## Resumo
Capturar o conhecimento institucional é fundamental para garantir o sucesso e a resiliência organizacional. O conhecimento institucional representa a sabedoria coletiva, as percepções e as experiências acumuladas pelos colaboradores ao longo do tempo, frequentemente de forma tácita e transmitidas informalmente. Essa riqueza de informações abrange abordagens únicas, práticas recomendadas e soluções para problemas complexos que podem não estar documentados em outros locais. Ao formalizar e documentar esse conhecimento, as empresas podem preservar a memória institucional, promover a inovação, aprimorar os processos de tomada de decisão e acelerar a curva de aprendizado dos novos colaboradores. Além disso, essa prática promove a colaboração, capacita os indivíduos e cultiva uma cultura de melhoria contínua. Por fim, aproveitar o conhecimento institucional ajuda as empresas a usar seu bem mais valioso, a inteligência coletiva de sua força de trabalho, para enfrentar desafios, impulsionar o crescimento e manter a vantagem competitiva em ambientes de negócios dinâmicos.
Esse padrão explica como capturar o conhecimento institucional por meio de gravações de voz de colaboradores experientes. Ele usa o [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) e o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) para documentação e verificação sistemáticas. Ao documentar esse conhecimento informal, você pode preservá-lo e compartilhá-lo com as futuras gerações de colaboradores. Essa iniciativa contribui para a excelência operacional e aprimora a eficácia dos programas de treinamento, incorporando o conhecimento prático adquirido por meio da experiência direta.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma conta AWS ativa
+ Docker, [instalado](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK), na versão 2.114.1 ou em versões posteriores, [instalado](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) e [inicializado](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) nas regiões da AWS `us-east-1` ou `us-west-2`
+ Kit de Ferramentas CDK da AWS, na versão 2.114.1 ou em versões posteriores, [instalado](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ AWS Command Line Interface (AWS CLI), [instalada](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [configurada](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ Python, versão 3.12 ou versões posteriores, [instalado](https://www.python.org/downloads/)
+ Permissões para criar recursos do Amazon Transcribe, do Amazon Bedrock, do Amazon Simple Storage Service (Amazon S3) e do AWS Lambda
**Limitações**
+ Essa solução é implantada em uma única conta da AWS.
+ Esta solução pode ser implantada somente nas regiões da AWS nas quais o Amazon Bedrock e o Amazon Transcribe estão disponíveis. Para obter informações sobre a disponibilidade, consulte a documentação do [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) e do [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html#tsc-regions).
+ Os arquivos de áudio devem estar em um formato compatível com o Amazon Transcribe. Para obter uma lista dos formatos compatíveis, consulte [Formatos de mídia](https://docs.aws.amazon.com/transcribe/latest/dg/how-input.html#how-input-audio) na documentação Transcribe.
**Versões do produto**
+ AWS SDK para Python (Boto3), na versão 1.34.57 ou em versões posteriores
+ LangChain versão 0.1.12 ou posterior
## Arquitetura
A arquitetura representa um fluxo de trabalho com tecnologia sem servidor na AWS. O [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) realiza a orquestração de funções do Lambda para o processamento de áudio, análise de texto e geração de documentos. O diagrama apresentado a seguir ilustra o fluxo de trabalho do Step Functions, também conhecido como *máquina de estado*.
![\[Diagrama da arquitetura da máquina de estado do Step Functions que gera um documento.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/f1e0106d-b046-4adc-9718-c299efb7b436/images/e90298ca-1b7f-4c3e-97bd-311a9d5a4997.png)
Cada etapa da máquina de estado é executada por uma função do Lambda distinta. A seguir, apresentamos as etapas que fazem parte do processo de geração de documentos:
1. A função do Lambda `preprocess` valida a entrada transferida para o Step Functions e lista todos os arquivos de áudio presentes no caminho da pasta URI do Amazon S3 fornecido. As funções do Lambda subsequentes no fluxo de trabalho usam a lista de arquivos para validar, resumir e gerar o documento.
1. A função do Lambda `transcribe` usa o Amazon Transcribe para converter arquivos de áudio em transcrições de texto Essa função do Lambda é responsável por iniciar o processo de transcrição e transformar com precisão a fala em texto, que será armazenado para processamento posterior.
1. A função do Lambda `validate` analisa as transcrições de texto, verificando a relevância das respostas em relação às perguntas iniciais. Ao usar um grande modelo de linguagem (LLM) por meio do Amazon Bedrock, as respostas são identificadas e distinguidas no tópico de respostas fora de contexto.
1. A função do Lambda `summarize` usa o Amazon Bedrock para gerar um resumo coerente e conciso das respostas pertinentes ao contexto.
1. A função do Lambda `generate` organiza os resumos em um documento bem estruturado. Essa função pode formatar o documento de acordo com modelos definidos previamente e incluir qualquer conteúdo ou dado adicional necessário.
1. Se alguma das funções do Lambda falhar, você receberá uma notificação por e-mail do Amazon Simple Notification Service (Amazon SNS).
Durante todo esse processo, o AWS Step Functions garante que cada função do Lambda seja iniciada na sequência correta. Esta máquina de estado conta com capacidade de processamento paralelo para aumentar a eficiência. Um bucket do Amazon S3 funciona como o repositório central de armazenamento, apoiando o fluxo de trabalho ao gerenciar os diversos formatos de mídia e os documentos envolvidos.
## Ferramentas
**Serviços da AWS**
+ [O Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) é um serviço totalmente gerenciado que disponibiliza modelos básicos de alto desempenho (FMs) das principais startups de IA e da Amazon para seu uso por meio de uma API unificada.
+ O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda você a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado.
+ O [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) ajuda você a coordenar e gerenciar a troca de mensagens entre publicadores e clientes, incluindo servidores web e endereços de e-mail.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
+ O [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) é um serviço de orquestração com tecnologia sem servidor que permite combinar funções do AWS Lambda e outros serviços da AWS para criar aplicações essenciais aos negócios.
+ O [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) é um serviço de reconhecimento de fala automático que emprega modelos de machine learning para converter áudio em texto.
**Outras ferramentas**
+ [LangChain](https://python.langchain.com/docs/get_started/introduction/)é uma estrutura para o desenvolvimento de aplicativos que são alimentados por grandes modelos de linguagem (LLMs).
**Repositório de código**
O código desse padrão está disponível no GitHub [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)repositório.
O repositório de código contém os seguintes arquivos e pastas:
+ Pasta `assets`: os recursos estáticos da solução, como o diagrama da arquitetura e o conjunto de dados público
+ Pasta `code/lambdas`: o código Python para todas as funções do Lambda
+ Pasta `code/lambdas/generate`: o código Python que gera um documento com base nos dados resumidos no bucket do S3
+ Pasta `code/lambdas/preprocess`: o código Python que processa as entradas para a máquina de estado do Step Functions
+ Pasta `code/lambdas/summarize`: o código Python que resume os dados transcritos usando o serviço Amazon Bedrock
+ Pasta `code/lambdas/transcribe`: o código Python que converte dados de fala (arquivo de áudio) em texto usando o Amazon Transcribe
+ Pasta `code/lambdas/validate`: o código Python que valida se todas as respostas se referem ao mesmo tópico
+ `code/code_stack.py`: o arquivo Python do constructo do AWS CDK usado para criar recursos da AWS
+ `app.py`: o arquivo Python da aplicação do AWS CDK usada para implantar recursos da AWS na conta da AWS de destino
+ `requirements.txt`: a lista de todas as dependências do Python que devem ser instaladas para o AWS CDK
+ `cdk.json`: o arquivo de entrada que fornece os valores necessários para criar recursos
## Práticas recomendadas
O exemplo de código fornecido é apenas para fins proof-of-concept (PoC) ou piloto. Se você pretende implantar a solução para a produção, siga as seguintes práticas recomendadas:
+ Habilitar o [registro em log de acesso do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
+ Habilitar os [logs de fluxo da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)
## Épicos
### Configuração de credenciais da AWS na estação de trabalho local
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Exporte variáveis para a conta e para a região da AWS. | Para fornecer credenciais da AWS ao AWS CDK usando variáveis de ambiente, execute os comandos apresentados a seguir.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps engenheiro |
| Configure o perfil nomeado da AWS CLI. | Para configurar o perfil nomeado da AWS CLI para a conta, siga as instruções apresentadas em [Configurações do arquivo de configuração e credenciais](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). | AWS DevOps, DevOps engenheiro |
### Configure o ambiente.
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Clone o repositório na sua estação de trabalho local. | Para clonar o [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)repositório, execute o comando a seguir no seu terminal.git clone https://github.com/aws-samples/genai-knowledge-capture
| AWS DevOps, DevOps engenheiro |
| (Opcional) Substitua os arquivos de áudio. | Para personalizar a aplicação de amostra e incorporar seus próprios dados, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps engenheiro |
| Configure o ambiente virtual do Python. | Para ativar o ambiente virtual do Python, execute os comandos a seguir.cd genai-knowledge-capture
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
| AWS DevOps, DevOps engenheiro |
| Sintetize o código do AWS CDK. | Para converter o código em uma configuração de CloudFormation pilha da AWS, execute o comando a seguir.cdk synth
| AWS DevOps, DevOps engenheiro |
### Configuração e implantação da solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Providencie o acesso ao modelo de base. | Habilite o acesso ao modelo Anthropic Claude 3 Sonnet para a sua conta da AWS. Para obter instruções, consulte [Adicionar acesso ao modelo](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-add) na documentação do Bedrock. | AWS DevOps |
| Implante recursos na conta. | Para implantar recursos na conta da AWS usando o AWS CDK, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps engenheiro |
| Assine o tópico do Amazon SNS. | Para se tornar assinante do tópico do Amazon SNS a fim de receber notificações, faça o seguinte:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS geral |
### Testar a solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Execute uma máquina de estado. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | Desenvolvedor de aplicativos, AWS geral |
### Limpe todos os recursos da AWS na solução
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Remova os recursos da AWS. | Após testar a solução, limpe os recursos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps engenheiro |
## Recursos relacionados
**Documentação da AWS**
+ Recursos do Amazon Bedrock:
+ [Acesso ao modelo](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parâmetros de inferência para modelos de fundação](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ Recursos do AWS CDK:
+ [Começar a usar o AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Trabalhar com o AWS CDK no Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Solução de problemas comuns do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Comandos do kit de ferramentas](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-commands)
+ Recursos do AWS Step Functions:
+ [Conceitos básicos do AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started-with-sfn.html)
+ [Solução de problemas](https://docs.aws.amazon.com/step-functions/latest/dg/troubleshooting.html)
+ [Criar funções do Lambda com Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Criador de aplicações de IA generativa na AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Outros recursos**
+ [LangChain documentação](https://python.langchain.com/docs/get_started/introduction)
# Gere recomendações personalizadas e reclassificadas usando o Amazon Personalize
*Mason Cahill, Matthew Chasse e Tayo Olajide, Amazon Web Services*
## Resumo
Esse padrão mostra como usar o Amazon Personalize para gerar recomendações personalizadas para seus usuários, incluindo recomendações reclassificadas, com base na ingestão de dados de interação do usuário em tempo real desses usuários. O cenário de exemplo usado nesse padrão é baseado em um site de adoção de animais de estimação que gera recomendações para seus usuários com base em suas interações (por exemplo, quais animais de estimação visitados pelo usuário). Neste cenário de exemplo, você aprenderá a usar o Amazon Kinesis Data Streams para ingerir dados de interação, o AWS Lambda para gerar recomendações e reordená-las, e o Amazon Data Firehose para armazenar os dados em um bucket do Amazon Simple Storage Service (Amazon S3). Você também aprende a usar o AWS Step Functions para criar uma máquina de estado que gerencia a versão da solução (ou seja, um modelo treinado) que gera suas recomendações.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma [conta AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) ativa com um AWS Cloud Development Kit (AWS CDK) [integrado](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) com credenciais configuradas
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
**Versões do produto**
+ Python 3.9
+ CDK da AWS: 2.23.0 ou superior
+ CLI da AWS: 2.7.27 ou superior
## Arquitetura
**Pilha de tecnologia**
+ Amazon Data Firehose
+ Amazon Kinesis Data Streams
+ Amazon Personalize
+ Amazon Simple Storage Service (Amazon S3)
+ AWS Cloud Development Kit (AWS CDK)
+ AWS Command Line Interface (AWS CLI)
+ AWS Lambda
+ AWS Step Functions
**Arquitetura de destino**
O diagrama a seguir ilustra um pipeline para a ingestão de dados em tempo real no Amazon Personalize. O pipeline então usa esses dados para gerar recomendações personalizadas e reclassificadas para os usuários.
![\[Arquitetura de ingestão de dados do Amazon Personalize\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/42eb193b-2347-408a-8b25-46beeb3b29ca/images/786dbd56-7d7f-41bb-90f6-d4485d73fe15.png)
O diagrama mostra o seguinte fluxo de trabalho:
1. O Kinesis Data Streams ingere dados de usuários em tempo real (por exemplo, eventos como animais de estimação visitados) para processamento pelo Lambda e pelo Firehose.
1. Uma função do Lambda processa os registros do Kinesis Data Streams e faz uma chamada de API para adicionar a interação do usuário no registro a um rastreador de eventos no Amazon Personalize.
1. Uma regra baseada em tempo invoca uma máquina de estado do Step Functions e gera novas versões da solução para os modelos de recomendação e reclassificação usando os eventos do rastreador de eventos no Amazon Personalize.
1. As [campanhas](https://docs.aws.amazon.com/personalize/latest/dg/campaigns.html) do Amazon Personalize são atualizadas pela máquina de estado para usar a nova [versão da solução](https://docs.aws.amazon.com/personalize/latest/dg/creating-a-solution-version.html).
1. O Lambda reclassifica a lista de itens recomendados chamando a campanha de reclassificação do Amazon Personalize.
1. O Lambda recupera a lista de itens recomendados chamando a campanha de recomendações do Amazon Personalize.
1. O Firehose armazena os eventos em um bucket do S3, permitindo acessá-los posteriormente como dados históricos.
## Ferramentas
**Ferramentas da AWS**
+ O [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) é uma estrutura de desenvolvimento de software que ajuda você a definir e provisionar a infraestrutura da Nuvem AWS em código.
+ A [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que permite que você interaja com serviços da AWS usando comandos no shell da linha de comando.
+ O [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) auxilia no envio de [dados de streaming](https://aws.amazon.com/streaming-data/) em tempo real para outros serviços da AWS, para endpoints HTTP personalizados e para endpoints HTTP de provedores de serviços terceirizados compatíveis.
+ O [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) ajuda a coletar e processar grandes fluxos de registros de dados em tempo real.
+ O [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) é um serviço de computação que ajuda você a executar código sem exigir provisionamento ou gerenciamento de servidores. Ele executa o código somente quando necessário e dimensiona automaticamente, assim, você paga apenas pelo tempo de computação usado.
+ O [Amazon Personalize](https://docs.aws.amazon.com/personalize/latest/dg/what-is-personalize.html) é um serviço de machine learning (ML) totalmente gerenciado que ajuda você a gerar recomendações de itens para seus usuários com base em seus dados.
+ O [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) é um serviço de orquestração sem servidor que permite combinar funções do Lambda e outros serviços da AWS para criar aplicações essenciais aos negócios.
**Outras ferramentas**
+ [pytest ](https://docs.pytest.org/en/7.2.x/index.html)é uma estrutura Python para escrever testes pequenos e legíveis.
+ [Python](https://www.python.org/) é uma linguagem de programação de computador de uso geral.
**Código **
O código desse padrão está disponível no repositório GitHub [Animal Recommender](https://github.com/aws-samples/personalize-pet-recommendations). Você pode usar o CloudFormation modelo da AWS desse repositório para implantar os recursos para a solução de exemplo.
**nota**
As versões da solução Amazon Personalize, o rastreador de eventos e as campanhas são apoiadas por [recursos personalizados](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-custom-resources.html) (dentro da infraestrutura) que expandem os recursos nativos. CloudFormation
## Épicos
### Criar a infraestrutura
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie um ambiente Python isolado. | **Configuração Mac/Linux**[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)**Configuração do Windows**Para criar manualmente um ambiente virtual, execute o `% .venv\Scripts\activate.bat` comando no seu terminal. | DevOps engenheiro |
| Sintetize o modelo. CloudFormation | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)Na etapa 2, `CDK_ENVIRONMENT` se refere ao arquivo `config/{env}.yml`. | DevOps engenheiro |
| Implante recursos e crie infraestrutura. | Para implantar os recursos da solução, execute o comando `./deploy.sh` no seu terminal.Esse comando instala as dependências necessárias do Python. Um script do Python cria um bucket do S3 e uma chave do AWS Key Management Service (AWS KMS) e, em seguida, adiciona os dados iniciais para as criações iniciais do modelo. Por fim, o script `cdk deploy` é executado para criar a infraestrutura restante.O treinamento de modelo inicial acontece durante a criação da pilha. Poderá levar até duas horas para a pilha terminar de ser criada. | DevOps engenheiro |
## Recursos relacionados
+ [Recomendador de animais](https://github.com/aws-samples/personalize-pet-recommendations) () GitHub
+ [Documentação de referência do CDK da AWS](https://docs.aws.amazon.com/cdk/api/v2/)
+ [Documentação do Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Otimize recomendações personalizadas para uma métrica de negócios de sua escolha com o Amazon Personalize](https://aws.amazon.com/blogs/machine-learning/optimize-personalized-recommendations-for-a-business-metric-of-your-choice-with-amazon-personalize/) (AWS Machine Learning Blog)
## Mais informações
**Exemplos de cargas e respostas**
*Função do Lambda de recomendação*
Para recuperar recomendações, envie uma solicitação para a função do Lambda de recomendação com uma carga no seguinte formato:
```
{
"userId": "3578196281679609099",
"limit": 6
}
```
O exemplo de resposta a seguir contém uma lista de grupos de animais:
```
[{"id": "1-domestic short hair-1-1"},
{"id": "1-domestic short hair-3-3"},
{"id": "1-domestic short hair-3-2"},
{"id": "1-domestic short hair-1-2"},
{"id": "1-domestic short hair-3-1"},
{"id": "2-beagle-3-3"},
```
Se você omitir o campo `userId`, a função retornará recomendações gerais.
*Reclassificar a função do Lambda*
Para usar a reclassificação, envie uma solicitação para a função do Lambda de reclassificação. A carga contém todos os itens a IDs serem reclassificados e seus metadados. `userId` Os dados de exemplo a seguir usam as classes Oxford Pets para `animal_species_id` (1=gato, 2=cachorro) e números inteiros de 1 a 5 para `animal_age_id` e `animal_size_id`:
```
{
"userId":"12345",
"itemMetadataList":[
{
"itemId":"1",
"animalMetadata":{
"animal_species_id":"2",
"animal_primary_breed_id":"Saint_Bernard",
"animal_size_id":"3",
"animal_age_id":"2"
}
},
{
"itemId":"2",
"animalMetadata":{
"animal_species_id":"1",
"animal_primary_breed_id":"Egyptian_Mau",
"animal_size_id":"1",
"animal_age_id":"1"
}
},
{
"itemId":"3",
"animalMetadata":{
"animal_species_id":"2",
"animal_primary_breed_id":"Saint_Bernard",
"animal_size_id":"3",
"animal_age_id":"2"
}
}
]
}
```
A função Lambda reclassifica esses itens e, em seguida, retorna uma lista ordenada que inclui o item IDs e a resposta direta do Amazon Personalize. Esta é uma lista classificada dos grupos de animais em que os itens estão e sua pontuação. O Amazon Personalize usa receitas de [Personalização do usuário](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html) e [Classificação personalizada](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-search.html) para incluir uma pontuação para cada item nas recomendações. Essas pontuações representam a certeza relativa que o Amazon Personalize tem em relação ao item que o usuário selecionará em seguida. As pontuações mais altas representam maior certeza.
```
{
"ranking":[
"1",
"3",
"2"
],
"personalizeResponse":{
"ResponseMetadata":{
"RequestId":"a2ec0417-9dcd-4986-8341-a3b3d26cd694",
"HTTPStatusCode":200,
"HTTPHeaders":{
"date":"Thu, 16 Jun 2022 22:23:33 GMT",
"content-type":"application/json",
"content-length":"243",
"connection":"keep-alive",
"x-amzn-requestid":"a2ec0417-9dcd-4986-8341-a3b3d26cd694"
},
"RetryAttempts":0
},
"personalizedRanking":[
{
"itemId":"2-Saint_Bernard-3-2",
"score":0.8947961
},
{
"itemId":"1-Siamese-1-1",
"score":0.105204
}
],
"recommendationId":"RID-d97c7a87-bd4e-47b5-a89b-ac1d19386aec"
}
}
```
*Carga útil do Amazon Kinesis*
A carga a ser enviada ao Amazon Kinesis tem o seguinte formato:
```
{
"Partitionkey": "randomstring",
"Data": {
"userId": "12345",
"sessionId": "sessionId4545454",
"eventType": "DetailView",
"animalMetadata": {
"animal_species_id": "1",
"animal_primary_breed_id": "Russian_Blue",
"animal_size_id": "1",
"animal_age_id": "2"
},
"animal_id": "98765"
}
}
```
**nota**
O campo `userId` é removido para um usuário não autenticado.
# Simplifique os fluxos de trabalho de aprendizado de máquina, do desenvolvimento local aos experimentos escaláveis, usando SageMaker IA e Hydra
*David Sauerwein, Marco Geiger e Julian Ferdinand Grueber, Amazon Web Services*
## Resumo
Esse padrão fornece uma abordagem unificada para configurar e executar algoritmos de aprendizado de máquina (ML), desde o teste local até a produção na Amazon SageMaker AI. Os algoritmos de ML são o foco deste padrão, mas sua abordagem se estende à engenharia de atributos, inferência e pipelines completos de ML. Esse padrão demonstra a transição do desenvolvimento de scripts locais para trabalhos de treinamento de SageMaker IA por meio de um exemplo de caso de uso.
Um fluxo de trabalho típico de ML consiste em desenvolver e testar soluções em uma máquina local, realizar experimentos em grande escala (por exemplo, com diferentes parâmetros) na nuvem e implantar a solução aprovada na nuvem. Após isso, a solução implantada precisa ser monitorada e mantida. Sem uma abordagem unificada para esse fluxo de trabalho, os desenvolvedores frequentemente precisam refatorar o código em cada etapa. Se a solução depender de um grande número de parâmetros que podem mudar em qualquer etapa desse fluxo de trabalho, pode se tornar cada vez mais complexo manter a organização e a consistência.
Este padrão aborda esses desafios. Primeiro, ele elimina a necessidade de refatoração de código entre ambientes, fornecendo um fluxo de trabalho unificado que permanece consistente, seja em execução em máquinas locais, em contêineres ou em IA. SageMaker Segundo, o padrão simplifica o gerenciamento de parâmetros por meio do sistema de configuração do Hydra, em que os parâmetros são definidos em arquivos de configuração separados, que podem ser facilmente modificados e combinados, com o registro em log automático da configuração de cada execução. Para obter mais detalhes sobre como este padrão aborda esses desafios, consulte a seção de [Informações adicionais](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional).
## Pré-requisitos e limitações
**Pré-requisitos **
+ Um ativo Conta da AWS
+ Uma [função de usuário AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) (IAM) para implantar e iniciar os trabalhos de treinamento de SageMaker IA
+ AWS Command Line Interface (AWS CLI) versão 2.0 ou posterior [instalada](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) e [configurada](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ [Poetry](https://python-poetry.org/) versão 1.8 ou versões posteriores, mas anterior à 2.0, instalada
+ [Docker](https://www.docker.com/) instalado
+ Python [versão 3.10.x](https://www.python.org/downloads/release/python-31011/)
**Limitações**
+ Atualmente, o código visa apenas trabalhos de treinamento de SageMaker IA. Estendê-lo para trabalhos de processamento e pipelines completos de SageMaker IA é simples.
+ Para uma configuração de SageMaker IA totalmente produtiva, detalhes adicionais precisam estar em vigor. Os exemplos podem ser chaves personalizadas AWS Key Management Service (AWS KMS) para computação e armazenamento ou configurações de rede. Além disso, é possível configurar essas opções adicionais usando o Hydra em uma subpasta específica dentro da pasta `config`.
+ Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [AWS Services by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado.
## Arquitetura
O diagrama a seguir representa a arquitetura da solução.
![\[Fluxo de trabalho para criar e executar treinamentos de SageMaker IA ou trabalhos de HPO.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/1db57484-f85c-49a6-b870-471dade02b26/images/d80e7474-a975-4d92-8f66-2d34e33053fd.png)
O diagrama mostra o seguinte fluxo de trabalho:
1. O cientista de dados pode iterar o algoritmo em pequena escala em um ambiente local, ajustar parâmetros e testar o script de treinamento rapidamente sem a necessidade de Docker ou SageMaker IA. (Para obter mais detalhes, consulte a tarefa “Realize a execução localmente para testes rápidos” na seção [Épicos](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics).)
1. Quando estiver satisfeito com o algoritmo, o cientista de dados desenvolve e envia por push a imagem do Docker para o repositório do Amazon Elastic Container Registry (Amazon ECR) chamado `hydra-sm-artifact`. (Para obter mais detalhes, consulte “Executar fluxos de trabalho em SageMaker IA” em [Epics](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics).)
1. O cientista de dados inicia trabalhos de treinamento de SageMaker IA ou de otimização de hiperparâmetros (HPO) usando scripts Python. Para as tarefas de treinamento regulares, a configuração ajustada é gravada no bucket do Amazon Simple Storage Service (Amazon S3) chamado `hydra-sample-config`. Para as tarefas de HPO, a configuração padrão localizada na pasta `config` é aplicada.
1. O trabalho de treinamento de SageMaker IA extrai a imagem do Docker, lê os dados de entrada do `hydra-sample-data` bucket do Amazon S3 e busca a configuração do bucket do Amazon S3 ou usa a configuração padrão`hydra-sample-config`. Após o treinamento, a tarefa salva os dados de saída no bucket do Amazon S3 chamado `hydra-sample-data`.
**Automação e escala**
+ [Para treinamento, reciclagem ou inferência automatizados, você pode integrar o AWS CLI código a serviços como [AWS Lambda[AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), ou Amazon. EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html)
+ A escalabilidade pode ser alcançada alterando as configurações de tamanhos de instância ou adicionando configurações para treinamento distribuído.
## Ferramentas
**Serviços da AWS**
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ajuda você a configurar AWS recursos, provisioná-los de forma rápida e consistente e gerenciá-los durante todo o ciclo de vida em Contas da AWS e. Regiões da AWS
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando. Para esse padrão, o AWS CLI é útil tanto para configuração inicial de recursos quanto para testes.
+ O [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) é um serviço gerenciado de registro de imagens de contêineres seguro, escalável e confiável.
+ O [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) é um serviço gerenciado de aprendizado de máquina (ML) que ajuda você a criar e treinar modelos de ML e depois implantá-los em um ambiente hospedado pronto para produção. SageMaker O treinamento de IA é um serviço de ML totalmente gerenciado dentro da SageMaker IA que permite o treinamento de modelos de ML em grande escala. A ferramenta pode lidar com as demandas computacionais de modelos de treinamento de forma eficiente, fazendo uso da escalabilidade integrada e da integração com outros. Serviços da AWS SageMaker O treinamento de IA também oferece suporte a algoritmos e contêineres personalizados, tornando-o flexível para uma ampla variedade de fluxos de trabalho de ML.
+ O [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) é um serviço de armazenamento de objetos baseado na nuvem que ajuda você a armazenar, proteger e recuperar qualquer quantidade de dados.
**Outras ferramentas**
+ O [Docker](https://www.docker.com/) é um conjunto de produtos de plataforma como serviço (PaaS) que usam a virtualização no nível do sistema operacional para fornecer software em contêineres. Foi usado neste padrão para garantir ambientes consistentes em várias etapas, desde o desenvolvimento até a implantação, e para empacotar dependências e código com confiabilidade. A containerização proporcionada pelo Docker possibilitou uma escalabilidade simples e um controle de versão em todo o fluxo de trabalho.
+ O [Hydra](https://hydra.cc/) é uma ferramenta de gerenciamento de configurações que proporciona flexibilidade no manuseio de diversas configurações e no gerenciamento dinâmico de recursos. Ela é fundamental no gerenciamento de configurações de ambiente, permitindo a implantação sem interrupções em diferentes ambientes. Para obter mais detalhes sobre o Hydra, consulte [Informações adicionais](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional).
+ [Python](https://www.python.org/) é uma linguagem de programação de computador de uso geral. O Python foi usado para gravar o código de ML e o fluxo de trabalho de implantação.
+ O [Poetry](https://python-poetry.org/) é uma ferramenta para gerenciamento de dependências e empacotamento em Python.
**Repositório de código**
O código desse padrão está disponível no repositório GitHub [configuring-sagemaker-training-jobs-with-hydra](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra).
## Práticas recomendadas
+ Escolha uma função do IAM para implantar e iniciar os trabalhos de treinamento de SageMaker IA que siga o princípio do menor privilégio e conceda as permissões mínimas necessárias para realizar uma tarefa. Para obter mais informações, consulte [Concessão de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e [nas melhores práticas de segurança](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) na documentação do IAM.
+ Use credenciais temporárias para acessar o perfil do IAM no terminal.
## Épicos
### Configurar o ambiente
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie e ative o ambiente virtual. | Para criar e ativar o ambiente virtual, execute os seguintes comandos na raiz do repositório:poetry install
poetry shell
| AWS geral |
| Implantar a infraestrutura. | Para implantar a infraestrutura usando CloudFormation, execute o seguinte comando:aws cloudformation deploy --template-file infra/hydra-sagemaker-setup.yaml --stack-name hydra-sagemaker-setup --capabilities CAPABILITY_NAMED_IAM
| AWS geral, DevOps engenheiro |
| Faça o download dos dados de amostra. | Para fazer o download dos dados de entrada do [openml](https://www.openml.org/) para sua máquina local, execute o seguinte comando:python scripts/download_data.py
| AWS geral |
| Realize a execução localmente para testes rápidos. | Para executar o código de treinamento localmente para fins de teste, use o seguinte comando:python mypackage/train.py data.train_data_path=data/train.csv evaluation.base_dir_path=data
Os logs de todas as execuções são armazenados e organizados pelo horário de execução em uma pasta chamada `outputs`. Para obter mais informações, consulte a seção “Saída” no [GitHub repositório.](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra)Além disso, é possível executar vários treinamentos simultaneamente, cada um com parâmetros distintos, por meio da funcionalidade `--multirun`. Para obter mais detalhes, consulte a [documentação do Hydra](https://hydra.cc/docs/tutorials/basic/running_your_app/multi-run/). | Cientista de dados |
### Execute fluxos de trabalho em IA SageMaker
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Defina as variáveis de ambiente. | Para executar seu trabalho na SageMaker IA, defina as seguintes variáveis de ambiente, fornecendo sua Região da AWS e sua Conta da AWS ID:export ECR_REPO_NAME=hydra-sm-artifact
export image_tag=latest
export AWS_REGION="" # for instance, us-east-1
export ACCOUNT_ID=""
export BUCKET_NAME_DATA=hydra-sample-data-$ACCOUNT_ID
export BUCKET_NAME_CONFIG=hydra-sample-config-$ACCOUNT_ID
export AWS_DEFAULT_REGION=$AWS_REGION
export ROLE_ARN=arn:aws:iam::${ACCOUNT_ID}:role/hydra-sample-sagemaker
export INPUT_DATA_S3_PATH=s3://$BUCKET_NAME_DATA/hydra-on-sm/input/
export OUTPUT_DATA_S3_PATH=s3://$BUCKET_NAME_DATA/hydra-on-sm/output/
| AWS geral |
| Crie e envie por push a imagem do Docker. | Para criar a imagem do Docker e enviá-la por push para o repositório do Amazon ECR, execute o seguinte comando:chmod +x scripts/create_and_push_image.sh
scripts/create_and_push_image.sh $ECR_REPO_NAME $image_tag $AWS_REGION $ACCOUNT_ID
Esta tarefa assume que há credenciais válidas configuradas no seu ambiente. A imagem do Docker é enviada para o repositório Amazon ECR especificado na variável de ambiente na tarefa anterior e é usada para ativar o contêiner de SageMaker IA no qual o trabalho de treinamento será executado. | Engenheiro de ML e usuário geral da AWS |
| Copie os dados de entrada para o Amazon S3. | O trabalho de treinamento de SageMaker IA precisa coletar os dados de entrada. Para copiar os dados de entrada para o bucket do Amazon S3 destinado aos dados, execute o seguinte comando: aws s3 cp data/train.csv "${INPUT_DATA_S3_PATH}train.csv" | Engenheiro de dados e usuário geral da AWS |
| Envie vagas de treinamento em SageMaker IA. | Para simplificar a execução dos scripts, especifique os parâmetros de configuração padrão no arquivo `default.yaml`. Além de garantir consistência entre as execuções, essa abordagem também oferece a flexibilidade de substituir as configurações padrão com facilidade, quando necessário. Veja o exemplo a seguir:python scripts/start_sagemaker_training_job.py sagemaker.role_arn=$ROLE_ARN sagemaker.config_s3_bucket=$BUCKET_NAME_CONFIG sagemaker.input_data_s3_path=$INPUT_DATA_S3_PATH sagemaker.output_data_s3_path=$OUTPUT_DATA_S3_PATH
| Usuário geral da AWS, engenheiro de ML e cientista de dados |
| Execute o ajuste de hiperparâmetros de SageMaker IA. | Executar o ajuste de hiperparâmetros de SageMaker IA é semelhante ao envio de um trabalho de treinamento de SageMaker AII. No entanto, o script de execução difere em alguns pontos importantes, como você pode conferir no arquivo [start\$1sagemaker\$1hpo\$1job.py](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra/blob/main/scripts/start_sagemaker_hpo_job.py) Os hiperparâmetros a serem ajustados devem ser fornecidos por meio da carga útil do boto3 e não por um canal para a tarefa de treinamento.Para iniciar a tarefa de otimização de hiperparâmetros (HPO), execute os seguintes comandos:python scripts/start_sagemaker_hpo_job.py sagemaker.role_arn=$ROLE_ARN sagemaker.config_s3_bucket=$BUCKET_NAME_CONFIG sagemaker.input_data_s3_path=$INPUT_DATA_S3_PATH sagemaker.output_data_s3_path=$OUTPUT_DATA_S3_PATH
| Cientista de dados |
## Solução de problemas
| Problema | Solução |
| --- | --- |
| Token expirado | Exporte novas AWS credenciais. |
| Permissões do IAM insuficientes | Certifique-se de exportar as credenciais de uma função do IAM que tenha todas as permissões necessárias do IAM para implantar o CloudFormation modelo e iniciar os trabalhos de treinamento de SageMaker IA. |
## Recursos relacionados
+ [Treine um modelo com a Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) (AWS documentação)
+ [O que é ajuste de hiperparâmetros?](https://aws.amazon.com/what-is/hyperparameter-tuning/#:~:text=Hyperparameter%20tuning%20allows%20data%20scientists,the%20model%20as%20a%20hyperparameter.)
## Mais informações
Este padrão aborda os seguintes desafios:
**Consistência do desenvolvimento local à implantação em grande escala** — Com esse padrão, os desenvolvedores podem usar o mesmo fluxo de trabalho, independentemente de estarem usando scripts Python locais, executando contêineres Docker locais, conduzindo grandes experimentos SageMaker em IA ou implantando em produção em IA. SageMaker Essa consistência é importante pelos seguintes motivos:
+ **Iteração mais ágil**: permite experimentações rápidas e locais sem a necessidade de grandes ajustes ao aumentar a escala verticalmente.
+ **Sem refatoração — A** transição para experimentos maiores em SageMaker IA é perfeita, não exigindo nenhuma revisão da configuração existente.
+ **Melhoria contínua**: desenvolver novos recursos e aprimorar continuamente o algoritmo é simples, pois o código permanece o mesmo em todos os ambientes.
**Gerenciamento de configuração**: este padrão usa o [Hydra](https://hydra.cc/), uma ferramenta de gerenciamento de configuração, para fornecer os seguintes benefícios:
+ Os parâmetros são definidos em arquivos de configuração, separados do código.
+ Diferentes conjuntos de parâmetros podem ser trocados ou combinados com facilidade.
+ O acompanhamento dos experimentos é simplificado, pois a configuração de cada execução é registrada em log automaticamente.
+ Experimentos na nuvem podem usar a mesma estrutura de configuração que as execuções locais, garantindo consistência.
Com o Hydra, é possível gerenciar a configuração de forma eficiente, possibilitando os seguintes recursos:
+ **Fragmentar as configurações**: separe as configurações do projeto em blocos menores e administráveis, passíveis de alterações independentes. Essa abordagem facilita o gerenciamento de projetos complexos.
+ **Ajustar padrões com facilidade**: altere rapidamente as configurações de linha de base, simplificando o teste de novas ideias.
+ **Alinhar entradas da CLI e arquivos de configuração**: combine de forma integrada as entradas da linha de comando com seus arquivos de configuração. Essa abordagem reduz a desordem e a confusão, tornando o projeto mais fácil de gerenciar ao longo do tempo.
# Traduza a linguagem natural em consultas DSL para consultas OpenSearch e Elasticsearch
*Tabby Ward, Nicholas Switzer e Breanne Warner, Amazon Web Services*
## Resumo
Esse padrão demonstra como usar modelos de linguagem grande (LLMs) para converter consultas de linguagem natural em linguagem específica de domínio de consulta (consulta DSL), o que facilita a interação dos usuários com serviços de pesquisa, como OpenSearch o Elasticsearch, sem amplo conhecimento da linguagem de consulta. Esse recurso é particularmente valioso para desenvolvedores e cientistas de dados que desejam aprimorar aplicações baseadas em pesquisa com recursos de consulta em linguagem natural, melhorando a experiência do usuário e a funcionalidade de pesquisa.
O padrão ilustra técnicas de engenharia de prompts, refinamento iterativo e incorporação de conhecimento especializado, todas cruciais na geração de dados sintéticos. Embora essa abordagem se concentre principalmente na conversão de consultas, ela demonstra implicitamente o potencial de aumento de dados e produção escalável de dados sintéticos. Essa base pode ser estendida para tarefas mais abrangentes de geração de dados sintéticos, para destacar o poder de unir entradas de LLMs linguagem natural não estruturadas com saídas estruturadas e específicas do aplicativo.
Essa solução não envolve ferramentas de migração ou implantação no sentido tradicional. Em vez disso, ele se concentra em demonstrar uma prova de conceito (PoC) para converter consultas de linguagem natural em consultas DSL usando. LLMs
+ O padrão usa um notebook Jupyter como step-by-step guia para configurar o ambiente e implementar a text-to-query conversão.
+ Ele usa o Amazon Bedrock para acessar LLMs, que são cruciais para interpretar a linguagem natural e gerar consultas apropriadas.
+ A solução foi projetada para funcionar com o Amazon OpenSearch Service. Você pode seguir um processo semelhante para o Elasticsearch, e é possível adaptar as consultas geradas para mecanismos de pesquisa semelhantes.
O [Query DSL](https://opensearch.org/docs/latest/query-dsl/) é uma linguagem de pesquisa flexível, baseada em JSON, usada para criar consultas complexas tanto no Elasticsearch quanto no. OpenSearch Ela permite a você especificar consultas no parâmetro de consulta das operações de pesquisa e oferece suporte a vários tipos de consulta. Uma consulta de DSL inclui consultas leaf e consultas compostas. As consultas leaf pesquisam valores específicos em determinados campos e abrangem consultas de texto completo, em nível de termo, geográficas, de junção, abrangência e especializadas. As consultas compostas atuam como invólucros para várias cláusulas leaf ou compostas e combinam seus resultados ou modificam seu comportamento. A query DSL oferece suporte para a criação de pesquisas sofisticadas, desde consultas simples de correspondência abrangente até consultas complexas com várias cláusulas que produzem resultados altamente específicos. A query DSL é particularmente valiosa para projetos que exigem recursos avançados de pesquisa, elaboração flexível de consultas e estruturas de consulta baseadas em JSON.
Esse padrão usa técnicas como solicitação de poucas fotos, solicitações do sistema, saída estruturada, encadeamento de solicitações, provisão de contexto e solicitações específicas de tarefas para conversão de DSL. text-to-query Para obter definições e exemplos dessas técnicas, consulte a seção [Informações adicionais](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional).
## Pré-requisitos e limitações
**Pré-requisitos **
Para usar o caderno Jupyter com eficiência para converter consultas em linguagem natural em query DSL, você precisa:
+ **Familiaridade com cadernos Jupyter**. Compreensão básica de como navegar e executar código em um ambiente de caderno Jupyter.
+ **Ambiente Python**. Um ambiente Python funcional, preferencialmente Python 3.x, com as bibliotecas necessárias instaladas.
+ **Elasticsearch ou OpenSearch conhecimento**. Conhecimento básico do Elasticsearch or OpenSearch, incluindo sua arquitetura e como realizar consultas.
+ **Conta da AWS**. Um ativo Conta da AWS para acessar o Amazon Bedrock e outros serviços relacionados.
+ **Bibliotecas e dependências**. Instalação de bibliotecas específicas mencionadas no notebook, como `boto3` para AWS interação e quaisquer outras dependências necessárias para a integração do LLM.
+ **Acesso a modelos no Amazon Bedrock**. Esse padrão usa três Claude LLMs da Anthropic. Abra o [console do Amazon Bedrock](https://console.aws.amazon.com/bedrock/) e escolha **Acesso a modelos**. Na próxima tela, escolha **Habilitar modelos específicos** e selecione estes três modelos:
+ Claude 3 Sonnet
+ Claude 3.5 Sonnet
+ Claude 3 Haiku
+ **Políticas do IAM e perfil do IAM adequados**. Para executar o notebook em um Conta da AWS, sua função AWS Identity and Access Management (IAM) requer a `SagemakerFullAccess` política, bem como a política fornecida na seção [Informações adicionais](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional), que você pode nomear`APGtext2querydslpolicy`. Essa política inclui a assinatura dos três modelos do Claude listados.
Ter esses pré-requisitos estabelecidos garante uma experiência tranquila ao trabalhar com o notebook e implementar a funcionalidade. text-to-query
**Limitações**
+ **Status da prova de conceito**. Este projeto serve principalmente como uma prova de conceito (PoC). Ele demonstra o potencial do uso LLMs para converter consultas de linguagem natural em DSL de consulta, mas pode não estar totalmente otimizado ou pronto para produção.
+ **Limitações do modelo**:
**Restrições da janela de contexto***.* Ao usar os LLMs que estão disponíveis no Amazon Bedrock, esteja ciente das limitações da janela de contexto:
Modelos do Claude (em setembro de 2024):
+ Claude 3 Opus: 200 mil tokens
+ Claude 3 Sonnet: 200 mil tokens
+ Claude 3 Haiku: 200 mil tokens
Outros modelos no Amazon Bedrock podem ter tamanhos de janela de contexto diferentes. Para obter as informações mais atualizadas, consulte a documentação mais recente.
**Disponibilidade do modelo***. *A disponibilidade de modelos específicos no Amazon Bedrock pode variar. Certifique-se de ter acesso aos modelos necessários antes de implementar essa solução.
+ **Limitações adicionais**
+ **Complexidade das consultas**. A eficácia da linguagem natural para a conversão em query DSL pode variar dependendo da complexidade da consulta de entrada.
+ **Compatibilidade da versão**. A consulta DSL gerada pode precisar de ajustes com base na versão específica do Elasticsearch ou na OpenSearch que você usa.
+ **Desempenho**. Este padrão fornece uma implementação de PoC, portanto, a velocidade e a precisão da geração de consultas podem não ser ideais para uso em produção em grande escala.
+ **Custos**. O uso LLMs no Amazon Bedrock gera custos. Esteja ciente da estrutura de preços do modelo escolhido. Para obter mais informações, consulte [Preços do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html).
+ **Manutenção**. Atualizações regulares nos prompts e na seleção de modelos podem ser necessárias para acompanhar os avanços na tecnologia de LLMs e as mudanças na sintaxe da query DSL.
**Versões do produto**
Essa solução foi testada no Amazon OpenSearch Service. Se você quiser usar o Elasticsearch, talvez seja necessário fazer algumas alterações para replicar a funcionalidade exata desse padrão.
+ **OpenSearch compatibilidade de versões**. **OpenSearch **mantém a compatibilidade com versões anteriores nas versões principais. Por exemplo:
+ OpenSearch Os clientes 1.x geralmente são compatíveis com clusters OpenSearch 1.x.
+ OpenSearch Os clientes 2.x geralmente são compatíveis com clusters OpenSearch 2.x.
No entanto, é sempre melhor usar a mesma versão secundária para o cliente e o cluster, quando possível.
+ **OpenSearch Compatibilidade de API**. **OpenSearch **mantém a compatibilidade da API com o Elasticsearch OSS 7.10.2 para a maioria das operações. No entanto, existem algumas diferenças, especialmente nas versões mais recentes.
+ **OpenSearch considerações de atualização**:
+ Não há suporte para downgrades diretos. Use snapshots para reversão, se necessário.
+ Ao atualizar, verifique a [matriz de compatibilidade e as notas de versão](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-operations.html) para ver se há alterações significativas.
**Considerações para o Elasticsearch**
+ **Versão do Elasticsearch**. A versão principal do Elasticsearch que você está usando é crucial, pois a sintaxe e os recursos da consulta podem mudar entre as versões principais. Atualmente, a versão estável mais recente é o Elasticsearch 8.x. Certifique-se de que as consultas sejam compatíveis com sua versão específica do Elasticsearch.
+ **Versão da biblioteca de query DSL do Elasticsearch**. Se você estiver usando a biblioteca de Python de query DSL do Elasticsearch, certifique-se de que a versão corresponda à sua versão do Elasticsearch. Por exemplo:
+ Para o Elasticsearch 8.x, use uma versão de `elasticsearch-dsl` posterior ou igual à 8.0.0, mas anterior à 9.0.0.
+ Para o Elasticsearch 7.x, use uma versão de `elasticsearch-dsl` posterior ou igual à 7.0.0, mas anterior à 8.0.0.
+ **Versões da biblioteca do cliente**. Se você estiver usando o cliente oficial do Elasticsearch ou um cliente específico de linguagem, certifique-se de que ele seja compatível com sua versão do Elasticsearch.
+ **Versão da query DSL**. A query DSL evolui com as versões do Elasticsearch. Alguns tipos ou parâmetros de consulta podem estar obsoletos ou serem introduzidos em versões diferentes.
+ **Versão de mapeamento**. A maneira de definir mapeamentos para os índices pode mudar entre as versões. Sempre verifique a documentação de mapeamento para sua versão específica do Elasticsearch.
+ **Versões de ferramentas de análise**. Se você estiver usando analisadores, tokenizadores ou outras ferramentas de análise de texto, o comportamento ou a disponibilidade deles pode mudar entre as versões.
## Arquitetura
**Arquitetura de destino**
O diagrama a seguir ilustra a arquitetura desse padrão.
![\[Arquitetura para traduzir a linguagem natural em query DSL no Amazon Bedrock.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/75296405-2893-4328-9551-9bcc6ec7fd3e/images/ffb1b893-d23c-4e1c-b679-8063b4f85a8a.png)
em que:
1. Entrada do usuário e prompt do sistema com exemplos de prompts few-shot. O processo começa com um usuário que fornece uma consulta em linguagem natural ou uma solicitação para geração de esquema.
1. Amazon Bedrock. A entrada é enviada para o Amazon Bedrock, que serve como interface para acessar o LLM do Claude.
1. LLM Sonnet do Claude 3 O Amazon Bedrock usa o Claude 3 Sonnet da família Claude 3 para processar LLMs a entrada. Ele interpreta e gera o Elasticsearch ou OpenSearch DSL de consulta apropriado. Para solicitações de esquema, ele gera mapeamentos ou Elasticsearch sintéticos. OpenSearch
1. Geração de query DSL. Para consultas em linguagem natural, o aplicativo pega a saída do LLM e a formata em uma DSL de consulta válida do Elasticsearch ou OpenSearch Service.
1. Geração de dados sintéticos. O aplicativo também usa esquemas para criar Elasticsearch sintético ou OpenSearch dados para serem carregados em uma coleção sem OpenSearch servidor para testes.
1. OpenSearch ou Elasticsearch. A consulta DSL gerada é consultada em relação a uma coleção OpenSearch Serverless em todos os índices. A saída JSON contém os dados relevantes e o número de *ocorrências* dos dados que residem na coleção OpenSearch Serverless.
**Automação e escala**
O código fornecido com esse padrão é criado estritamente para fins de PoC. A lista a seguir fornece algumas sugestões para automatizar e escalar ainda mais a solução e mover o código para a produção. Esses aprimoramentos estão fora do escopo desse padrão.
+ Conteinerização:
+ Coloque a aplicação em um contêiner do Docker para garantir a consistência em diferentes ambientes.
+ Use plataformas de orquestração de contêiner, como o Amazon Elastic Container Service (Amazon ECS) ou o Kubernetes, para implantações escaláveis.
+ Arquitetura com tecnologia sem servidor:
+ Converta a funcionalidade principal em AWS Lambda funções.
+ Use o Amazon API Gateway para criar RESTful endpoints para a entrada da consulta em linguagem natural.
+ Processamento assíncrono:
+ Implemente o Amazon Simple Queue Service (Amazon SQS) para enfileirar consultas recebidas.
+ Use AWS Step Functions para orquestrar o fluxo de trabalho de processamento de consultas e geração de consultas DSL.
+ Armazenamento em cache:
+ Implemente um mecanismo para armazenar os prompts em cache.
+ Monitoramento e registro em log:
+ Use a Amazon CloudWatch para monitoramento e alertas.
+ Implemente o registro centralizado com o Amazon CloudWatch Logs ou o Amazon OpenSearch Service para análise de registros.
+ Melhorias de segurança:
+ Implemente perfis do IAM para controle de acesso refinado.
+ Use AWS Secrets Manager para armazenar e gerenciar com segurança as chaves e credenciais da API.
+ Implantação multirregião:
+ Considere implantar a solução em vários Regiões da AWS para melhorar a latência e a recuperação de desastres.
+ Use o Amazon Route 53 para roteamento inteligente de solicitações.
Ao implementar essas sugestões, você pode transformar essa PoC em uma solução robusta, escalável e pronta para produção. Convém testar completamente cada componente e todo o sistema antes da implantação completa.
## Ferramentas
**Ferramentas**
+ Os notebooks [Amazon SageMaker AI são notebooks](https://aws.amazon.com/sagemaker/notebooks/) Jupyter totalmente gerenciados para desenvolvimento de aprendizado de máquina. Esse padrão usa notebooks como um ambiente interativo para exploração de dados, desenvolvimento de modelos e experimentação na Amazon SageMaker AI. Os notebooks oferecem integração perfeita com outros recursos de SageMaker IA e. Serviços da AWS
+ [Python](https://www.python.org/) é uma linguagem de programação de computador de uso geral. Este padrão usa Python como a linguagem principal para implementar a solução.
+ [O Amazon Bedrock](https://aws.amazon.com/bedrock/) é um serviço totalmente gerenciado que disponibiliza modelos básicos de alto desempenho (FMs) das principais startups de IA e da Amazon para seu uso por meio de uma API unificada. O Amazon Bedrock fornece acesso ao processamento LLMs de linguagem natural. Este padrão usa modelos da Anthropic para o Claude 3.
+ [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)é um kit de desenvolvimento de software que ajuda você a integrar seu aplicativo, biblioteca ou script em Python, incluindo o Amazon Serviços da AWS Bedrock.
+ O [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) é um serviço gerenciado que ajuda você a implantar, operar e escalar clusters de OpenSearch serviços na nuvem da AWS. Esse padrão usa o OpenSearch Service como o sistema de destino para gerar a consulta DSL.
**Repositório de código**
O código desse padrão está disponível no repositório GitHub [Prompt Engineering Text-to-QueryDSL Using Claude 3 Models](https://github.com/aws-samples/text-to-queryDSL/blob/main/text2ES_prompting_guide.ipynb). O exemplo usa uma aplicação de rede social de saúde que cria publicações para usuários e perfis de usuário associados à aplicação de saúde.
## Práticas recomendadas
Ao trabalhar com esta solução, considere o seguinte:
+ A necessidade de AWS credenciais e permissões adequadas para acessar o Amazon Bedrock
+ Custos potenciais associados ao uso Serviços da AWS e LLMs
+ A importância de ter conhecimento em query DSL para validar e possivelmente modificar as consultas geradas
## Épicos
### Configurar o ambiente e preparar os dados
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Configure o ambiente de desenvolvimento. | [Para obter instruções e códigos detalhados para essa e outras etapas desse padrão, consulte o passo a passo abrangente no GitHub repositório.](https://github.com/aws-samples/text-to-queryDSL/blob/main/text2ES_prompting_guide.ipynb)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/translate-natural-language-query-dsl-opensearch-elasticsearch.html) | Python, pip, AWS SDK |
| Configure o AWS acesso. | Configure o cliente Amazon Bedrock e a sessão de SageMaker IA. Recupere o Amazon Resource Name (ARN) para SageMaker a função de execução de IA para uso posterior na criação OpenSearch da coleção Serverless. | IAM, AWS CLI, Amazon Bedrock, Amazon SageMaker |
| Carregue os esquemas de aplicações de saúde. | Leia e analise esquemas JSON para publicações de saúde e perfis de usuário com base em arquivos predefinidos. Converta esquemas em strings para uso posterior em prompts. | DevOps engenheiro, AWS geral, Python, JSON |
### Gerar dados sintéticos
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie um gerador de dados baseado em LLM. | Implemente a função **generate\$1data()** para chamar a API Converse do Amazon Bedrock com modelos do Claude 3. Configure o modelo IDs para Sonnet, Sonnet 3.5 e Haiku:model_id_sonnet3_5 = "anthropic.claude-3-5-sonnet-20240620-v1:0"
model_id_sonnet = "anthropic.claude-3-sonnet-20240229-v1:0"
model_id_haiku = "anthropic.claude-3-haiku-20240307-v1:0"
| Python, API do Amazon Bedrock, prompts de LLM |
| Crie publicações de saúde sintéticas. | Use a função **generate\$1data()** com um prompt de mensagem específico para criar entradas de publicação de saúde sintéticas com base no esquema fornecido. Este é um exemplo de chamada de função: health_post_data = generate_data(bedrock_rt, model_id_sonnet, system_prompt, message_healthpost, inference_config)
| Python, JSON |
| Crie perfis de usuário sintéticos. | Use a função **generate\$1data()** com um prompt de mensagem específico para criar entradas de perfil de usuário sintéticas com base no esquema fornecido. O processo é semelhante à geração de publicações de saúde, mas usa um prompt diferente. | Python, JSON |
### Configurar OpenSearch e ingerir dados
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Configure uma coleção OpenSearch sem servidor. | Use o Boto3 para criar uma coleção OpenSearch sem servidor com políticas apropriadas de criptografia, rede e acesso. Este é um exemplo de criação da coleção: collection = aoss_client.create_collection(name=es_name, type='SEARCH')
[Para obter mais informações sobre o OpenSearch Serverless, consulte a AWS documentação.](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless.html) | OpenSearch Sem servidor, IAM |
| Defina OpenSearch índices. | Crie índices para postos de saúde e perfis de usuário usando o OpenSearch cliente, com base nos mapeamentos de esquema predefinidos. Este é um exemplo de criação do índice:response_health = oss_client.indices.create(healthpost_index, body=healthpost_body)
| OpenSearch, JSON |
| Carregue dados em OpenSearch. | Execute a função **ingest\$1data ()** para inserir em massa as publicações de saúde sintéticas e os perfis de usuário em seus respectivos índices. OpenSearch A função usa o assistente de operações em massa de `opensearch-py`:success, failed = bulk(oss_client, actions)
| Python, OpenSearch API, operações de dados em massa |
### Gerar e executar consultas
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie alguns exemplos de prompts few-shot. | Gere exemplos de consultas e perguntas em linguagem natural correspondentes usando modelos do Claude 3 para servir como exemplos de few-shot para a geração de consultas. O prompt do sistema inclui estes exemplos:system_prompt_query_generation = [{"text": f"""You are an expert query dsl generator. ... Examples: {example_prompt} ..."""}] | Prompts de LLM, query DSL |
| Crie um conversor text-to-query DSL. | Implemente o prompt do sistema, que inclui esquemas, dados e exemplos de few-shot, para geração de consultas. Use o prompt do sistema para converter consultas em linguagem natural em query DSL. Este é um exemplo de chamada de função:query_response = generate_data(bedrock_rt, model_id, system_prompt_query_generation, query, inference_config)
| Python, API do Amazon Bedrock, prompts de LLM |
| Teste a consulta DSL ativada. OpenSearch | Execute a função **query\$1oss ()** para executar a consulta DSL gerada na coleção OpenSearch Serverless e retornar os resultados. A função usa o método de pesquisa do OpenSearch cliente:response = oss_client.search(index="_all", body=temp)
| Python, OpenSearch API, consulta DSL |
### Testar e avaliar
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie um conjunto de consultas de teste. | Use o Claude 3 para gerar um conjunto diversificado de perguntas de teste com base nos dados e esquemas sintéticos:test_queries = generate_data(bedrock_rt, model_id_sonnet, query_system_prompt, query_prompt, inference_config)
| Prompts de LLM |
| Avalie a precisão da conversão de query DSL. | Teste a consulta DSL gerada executando consultas OpenSearch e analisando a relevância e a precisão dos resultados retornados. Isso envolve executar a consulta e inspecionar as ocorrências:output = query_oss(response1) print("Response after running query against Opensearch") print(output) | Python, análise de dados, query DSL |
| Compare os modelos do Claude 3 | Compare a performance de diferentes modelos do Claude 3 (Haiku, Sonnet, Sonnet 3.5) para geração de consultas em termos de precisão e latência. Para comparar, altere o `model_id` quando você chamar **generate\$1data()** e calcule o tempo de execução. | Python, avaliação comparativa de performance |
### Limpar e documentar
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Desenvolva um processo de limpeza. | Exclua todos os índices da coleção OpenSearch Serverless após o uso. | Python, SDK da AWS, API OpenSearch |
## Recursos relacionados
+ [Consulta DSL](https://opensearch.org/docs/latest/query-dsl/) (OpenSearch documentação)
+ [Documentação OpenSearch do Amazon Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html)
+ [OpenSearch Coleções sem servidor](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-manage.html)
+ [Documentação do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)
+ [Documentação da Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)
+ [AWS SDK para Python (Boto3) documentação](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Mais informações
**Política do IAM**
Esta é a política `APGtext2querydslpolicy` para o perfil do IAM usado neste padrão:
```
{
"Version": "2012-10-17",
"Statement": [
{ "Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"bedrock:InvokeModelWithResponseStream"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::sagemaker-*",
"arn:aws:s3:::sagemaker-*/*"
]
},
{ "Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/sagemaker/*"
},
{ "Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"aoss:*"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"iam:PassRole",
"sagemaker:*"
],
"Resource": [
"arn:aws:iam::*:role/*", "*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{ "Effect": "Allow",
"Action": [
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetRepository",
"codecommit:ListBranches",
"codecommit:ListRepositories"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"aws-marketplace:Subscribe"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws-marketplace:ProductId": [
"prod-6dw3qvchef7zy",
"prod-m5ilt4siql27k",
"prod-ozonys2hmmpeu"
]
}
}
},
{ "Effect": "Allow",
"Action": [
"aws-marketplace:Unsubscribe",
"aws-marketplace:ViewSubscriptions"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": "iam:*",
"Resource": "*"
}
]
}
```
**Técnicas de geração de prompts com modelos da Anthropic para o Claude 3**
Esse padrão demonstra as seguintes técnicas de solicitação para conversão text-to-query DSL usando modelos Claude 3.
+ **Prompts few-shot:** a geração de prompts few-shot é uma técnica poderosa para melhorar a performance dos modelos do Claude 3 no Amazon Bedrock. Essa abordagem envolve fornecer ao modelo um pequeno número de exemplos que demonstram o input/output comportamento desejado antes de solicitar que ele execute uma tarefa semelhante. Quando você usa modelos do Claude 3 no Amazon Bedrock, os prompts few-shot podem ser particularmente eficazes para tarefas que exigem formatação específica, padrões de raciocínio ou conhecimento de domínio. Para implementar essa técnica, você normalmente estrutura seu prompt com dois componentes principais: a seção de exemplo e a consulta real. A seção de exemplo contém um ou mais input/output pares que ilustram a tarefa, e a seção de consulta apresenta a nova entrada para a qual você deseja uma resposta. Esse método ajuda o Claude 3 a entender o contexto e o formato de saída esperado e geralmente resulta em uma resposta mais precisa e consistente.
Exemplo:
```
"query": {
"bool": {
"must": [
{"match": {"post_type": "recipe"}},
{"range": {"likes_count": {"gte": 100}}},
{"exists": {"field": "media_urls"}}
]
}
}
Question: Find all recipe posts that have at least 100 likes and include media URLs.
```
+ **Prompts do sistema:** além de alguns prompts few-shot, os modelos do Claude 3 no Amazon Bedrock também oferecem suporte ao uso de prompts do sistema. Os prompts do sistema são uma forma de fornecer contexto geral, instruções ou diretrizes ao modelo antes de apresentá-lo com entradas específicas do usuário. Eles são particularmente úteis para definir o tom, definir o perfil do modelo ou estabelecer restrições para toda a conversa. Para usar um prompt do sistema com o Claude 3 no Amazon Bedrock, inclua o parâmetro `system` da sua solicitação de API. Esse processo é separado das mensagens do usuário e se aplica a toda a interação. Os prompts detalhados do sistema são usados para definir o contexto e fornecer diretrizes para o modelo.
Exemplo:
```
You are an expert query dsl generator. Your task is to take an input question and generate a query dsl to answer the question. Use the schemas and data below to generate the query.
Schemas: [schema details]
Data: [sample data]
Guidelines:
- Ensure the generated query adheres to DSL query syntax
- Do not create new mappings or other items that aren't included in the provided schemas.
```
+ **Saída estruturada**: você pode instruir o modelo a fornecer a saída em formatos específicos, como JSON ou em marcações XML.
Exemplo:
```
Put the query in json tags
```
+ **Encadeamento de prompts**: o caderno usa a saída de uma chamada de LLM como entrada para outra, como usar dados sintéticos gerados para criar exemplos de perguntas.
+ **Fornecimento de contexto**: o contexto relevante, incluindo esquemas e dados de amostra, é fornecido nos prompts.
Exemplo:
```
Schemas: [schema details]
Data: [sample data]
```
+ **Prompts de tarefas específicas**: prompts diferentes são criados para tarefas específicas, como gerar dados sintéticos, criar exemplos de perguntas e converter consultas em linguagem natural em query DSL.
Exemplo para gerar perguntas de teste:
```
Your task is to generate 5 example questions users can ask the health app based on provided schemas and data. Only include the questions generated in the response.
```
# Uso do Amazon Q Developer como um assistente de codificação para aumentar a produtividade
*Ram Kandaswamy, Amazon Web Services*
## Resumo
Esse padrão usa um tic-tac-toe jogo para demonstrar como você pode aplicar o Amazon Q Developer em uma variedade de tarefas de desenvolvimento. Ele gera código para um tic-tac-toe jogo como um aplicativo de página única (SPA), aprimora sua interface de usuário e cria scripts para implantar o aplicativo. AWS
O Amazon Q Developer funciona como um assistente de codificação para impulsionar os fluxos de trabalho de desenvolvimento de software e aumentar a produtividade tanto de desenvolvedores quanto de usuários sem experiência em programação. Independentemente do seu conhecimento técnico, a solução auxilia na criação de arquiteturas e na elaboração de soluções para problemas empresariais, configura seu ambiente de trabalho, ajuda na implementação de novos recursos e gera casos de testes para validação. A solução usa instruções em linguagem natural e funcionalidades de IA para garantir código consistente e de alta qualidade, além de mitigar desafios relacionados à codificação, independentemente das suas habilidades de programação.
A principal vantagem do Amazon Q Developer está na capacidade de poupar você de tarefas de codificação repetitivas. Quando você usa a anotação `@workspace`, o Amazon Q Developer ingere e indexa todos os arquivos de codificação, as configurações e a estrutura do projeto no seu ambiente de desenvolvimento integrado (IDE), fornecendo respostas personalizadas para apoiar sua criatividade na resolução de problemas. Você pode dedicar mais tempo a projetar soluções inovadoras e aprimorar a experiência do usuário. Caso não tenha experiência técnica, você pode recorrer ao Amazon Q Developer para otimizar fluxos de trabalho e trabalhar melhor com a equipe de desenvolvimento. O recurso **Explicar códigos** do Amazon Q Developer disponibiliza instruções detalhadas e resumos, permitindo que você navegue por bases de codificação complexas.
Além disso, o Amazon Q Developer oferece uma abordagem que não depende da linguagem para ajudar desenvolvedores iniciantes e intermediários a desenvolver novas habilidades. Você pode se concentrar nos conceitos principais e na lógica de negócio, em vez de lidar com a sintaxe própria de cada linguagem. Isso reduz a curva de aprendizado ao migrar entre tecnologias.
## Pré-requisitos e limitações
**Pré-requisitos **
+ IDE (por exemplo, WebStorm ou Visual Studio Code) com o plug-in Amazon Q Developer instalado. Para obter instruções, consulte [Installing the Amazon Q Developer extension or plugin in your IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html) na documentação do Amazon Q Developer.
+ Uma Conta da AWS configuração ativa com o Amazon Q Developer. Para obter instruções, consulte [Getting started](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/getting-started-q-dev.html) na documentação do Amazon Q Developer.
+ **npm** instalado. Para obter instruções, consulte a [documentação do npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm). Este padrão foi testado com a versão 10.8 do npm.
+ AWS Command Line Interface (AWS CLI) instalado. Para obter instruções, consulte a [documentação do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Limitações**
+ O Amazon Q Developer consegue executar apenas uma tarefa de desenvolvimento por vez.
+ Alguns Serviços da AWS não estão disponíveis em todos Regiões da AWS. Para conferir a disponibilidade de uma região, consulte [Serviços da AWS by Region](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Para endpoints específicos, consulte a página [Cotas e endpoints de serviços](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e clique no link correspondente ao serviço desejado.
## Ferramentas
+ Esse padrão requer um IDE, como o Visual Studio Code ou WebStorm. Para obter uma lista dos compatíveis IDEs, consulte a [documentação do Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE.html#supported-ides-features).
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta de código aberto que ajuda você a interagir Serviços da AWS por meio de comandos em seu shell de linha de comando.
## Práticas recomendadas
Consulte [as melhores práticas de codificação com o Amazon Q Developer](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/best-practices-coding.html) na orientação AWS prescritiva. Além disso:
+ Ao fornecer prompts ao Amazon Q Developer, certifique-se de que suas instruções sejam claras e inequívocas. Inclua trechos do código e anotações como `@workspace` no prompt para fornecer mais contexto aos prompts.
+ Inclua as bibliotecas relevantes e importe-as para evitar conflitos ou interpretações incorretas por parte do sistema.
+ Caso o código gerado não seja preciso ou não corresponda ao esperado, use a opção **Fornecer feedback e gerar novamente**. Tente dividir os prompts em instruções menores.
## Épicos
### Configuração do ambiente de trabalho
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Criar um novo projeto da . | Para criar um novo projeto em seu ambiente de trabalho, execute o comando apresentado a seguir e aceite as configurações padrão para todas as perguntas:npx create-next-app@latest
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Teste a aplicação base. | Execute o comando apresentado a seguir e confirme que a aplicação base foi carregada com êxito no navegador:npm run dev
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Limpe o código base. | Acesse o arquivo `page.tsx`, localizado na pasta `src/app`, e remova o conteúdo padrão para obter uma página em branco. Após a exclusão, o arquivo deve ter a seguinte aparência:export default function Home() {
return (
);
} | Desenvolvedor de aplicações, programador e desenvolvedor de software |
### Use o Amazon Q Developer para criar um projeto de tic-tac-toe jogo
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Obtenha uma visão geral das etapas. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Gere código para tic-tac-toe. | No painel de chat, inicie uma tarefa de desenvolvimento usando o comando `/dev` seguido da descrição da tarefa. Por exemplo:/dev Create a React-based single-page application written in TypeScript for a tic-tac-toe game with the following specifications:
1. Design an aesthetically pleasing interface with the game grid centered vertically and
horizontally on the page.
2. Include a heading and clear instructions on how to play the game.
3. Implement color-coding for X and O marks to distinguish them easily.
O Amazon Q Developer gera código com base nas suas instruções. | Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Inspecione e aceite o código gerado. | Inspecione visualmente o código e clique em **Aceitar código** para substituir automaticamente o arquivo `page.tsx`.Se houver algum problema, escolha **Fornecer feedback e gerar novamente** e descreva o que aconteceu. | Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Corrija os erros de análise de código. | O tic-tac-toe jogo de exemplo inclui uma grade. O código gerado pelo Amazon Q Developer pode usar o tipo padrão `any`. É possível reforçar a segurança de tipos ao instruir o Amazon Q Developer desta maneira:/dev Ensure proper TypeScript typing for the onSquare Click event handler
to resolve any 'any' type issues.
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Adicione atratividade visual. | Você pode dividir o requisito original em fragmentos menores. Por exemplo, é possível otimizar a interface do usuário do jogo com os prompts apresentados a seguir para as tarefas de desenvolvimento. Este prompt aprimora os estilos em Cascading Style Sheets (CSS) e exporta a aplicação para implantação./dev Debug and fix any CSS issues to correctly display the game grid and overall layout.
Simplify the code by removing game history functionality and related components.
Implement static file export to an 'out' directory for easy deployment. The solution
should be fully functional, visually appealing, and free of typing errors or layout issues.
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Teste novamente. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Desenvolvedor de aplicações, programador e desenvolvedor de software |
### Implante o aplicativo no Nuvem AWS
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Crie as pastas e os arquivos necessários para a implantação. | No projeto, em seu ambiente de trabalho, crie uma pasta de implantação e, dentro dela, dois arquivos: `pushtos3.sh` e `cloudformation.yml`:mkdir deployment && cd deployment
touch pushtos3.sh && chmod +x pushtos3.sh
touch cloudformation.yml
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Gere o código de automação. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Administrador da AWS, AWS DevOps, desenvolvedor de aplicativos |
| Gere o conteúdo para o script. | Para criar um script de implantação, use o seguinte prompt:/dev Modify the pushtos3 shell script so that it can use AWS CLI commands to create a
CloudFormation stack named tictactoe-stack if it does not exist already, and use
cloudformation.yml as the source template. Wait for the stack to complete and sync the
contents from the out folder to the S3 bucket. Perform invalidation of the CloudFront
origin.
| Desenvolvedor de aplicações, programador e desenvolvedor de software |
| Implante a aplicação na Nuvem AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Administrador da AWS, AWS DevOps, arquiteto de nuvem, desenvolvedor de aplicativos |
## Solução de problemas
| Problema | Solução |
| --- | --- |
| A compilação não cria uma aplicação de página única nem a exporta para a pasta de saída. | Verifique o conteúdo do arquivo `next.config.mjs`.Se o código estiver com a seguinte configuração padrão:const nextConfig = {};modifique-o da seguinte maneira:const nextConfig = {
output: 'export',
distDir: 'out',
}; |
## Recursos relacionados
+ [Creating a new React project](https://react.dev/learn/start-a-new-react-project) (documentação do React)
+ [Visão geral do Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) (AWS documentação)
+ [Melhores práticas para desenvolvedores do Amazon Q](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/introduction.html) (AWS orientação prescritiva)
+ [Instalando, configurando e usando o Amazon Q Developer com JetBrains IDEs](https://www.youtube.com/watch?v=-iQfIhTA4J0&pp=ygUSYW1hem9uIHEgZGV2ZWxvcGVy) (YouTube vídeo)
+ [Instalando o Amazon Q para a linha de comando](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-getting-started-installing.html) (AWS documentação)
# Use o SageMaker processamento para engenharia de recursos distribuídos de conjuntos de dados de ML em escala de terabytes
*Chris Boomhower, Amazon Web Services*
## Resumo
Muitos conjuntos de dados em escala de terabytes ou maiores geralmente consistem em uma estrutura hierárquica de pastas e os arquivos no conjunto de dados às vezes compartilham interdependências. Por esse motivo, engenheiros de machine learning (ML) e cientistas de dados devem tomar decisões de design ponderadas para preparar esses dados para treinamento e inferência de modelos. Esse padrão demonstra como você pode usar técnicas manuais de macrofragmentação e microfragmentação em combinação com o Amazon SageMaker Processing e a paralelização de CPU virtual (vCPU) para escalar com eficiência os processos de engenharia de recursos para conjuntos de dados ML de big data complicados.
Esse padrão define *macrofragmentação* como a divisão de diretórios de dados em várias máquinas para processamento e *microfragmentação* como a divisão de dados em cada máquina em vários segmentos de processamento. [O padrão demonstra essas técnicas usando a Amazon SageMaker com amostras de registros de formas de onda de séries temporais do conjunto de dados MIMIC-III. PhysioNet ](https://physionet.org/content/mimic3wdb/1.0/) Ao implementar as técnicas nesse padrão, você pode minimizar o tempo de processamento e os custos da engenharia de atributos e, ao mesmo tempo, maximizar a utilização dos recursos e a eficiência de throughput. Essas otimizações dependem do SageMaker processamento distribuído nas instâncias do Amazon Elastic Compute Cloud (Amazon EC2) e v CPUs para conjuntos de dados grandes e semelhantes, independentemente do tipo de dados.
## Pré-requisitos e limitações
**Pré-requisitos **
+ Acesso às instâncias do SageMaker notebook ou ao SageMaker Studio, se você quiser implementar esse padrão para seu próprio conjunto de dados. Se você estiver usando a Amazon SageMaker pela primeira vez, consulte [Comece a usar a Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html) na documentação da AWS.
+ SageMaker Studio, se você quiser implementar esse padrão com os dados de amostra do [PhysioNet MIMIC-III](https://physionet.org/content/mimic3wdb/1.0/).
+ O padrão usa SageMaker Processing, mas não exige nenhuma experiência na execução de trabalhos SageMaker de Processing.
**Limitações**
+ Esse padrão é adequado para conjuntos de dados de ML que incluem arquivos interdependentes. Essas interdependências são as que mais se beneficiam da fragmentação manual de macros e da execução paralela de várias tarefas de processamento de instância única SageMaker . Para conjuntos de dados em que essas interdependências não existem, o `ShardedByS3Key` recurso em SageMaker Processing pode ser uma alternativa melhor à macrofragmentação, pois envia dados fragmentados para várias instâncias que são gerenciadas pela mesma tarefa de Processamento. No entanto, você pode implementar a estratégia de microfragmentação desse padrão em ambos os cenários para melhor utilizar a instância v. CPUs
**Versões do produto**
+ SDK do Amazon SageMaker Python versão 2
## Arquitetura
**Pilha de tecnologias de destino**
+ Amazon Simple Storage Service (Amazon S3)
+ Amazon SageMaker
**Arquitetura de destino**
*Macrofragmentação e instâncias distribuídas EC2 *
Os 10 processos paralelos representados nessa arquitetura refletem a estrutura do conjunto de dados MIMIC-III. (Os processos são representados por elipses para simplificar o diagrama.) Uma arquitetura semelhante se aplica a qualquer conjunto de dados quando você usa macrofragmentação manual. No caso do MIMIC-III, você pode usar a estrutura bruta do conjunto de dados a seu favor, processando cada pasta de grupo de pacientes separadamente, com o mínimo esforço. No diagrama a seguir, o bloco de grupos de registros aparece à esquerda (1). Dada a natureza distribuída dos dados, faz sentido fragmenta-los por grupo de pacientes.
![\[Arquitetura para microfragmentação e instâncias distribuídas EC2\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/images/c19a8f87-ac59-458e-89cb-50be17ca4a0c.png)
No entanto, a fragmentação manual por grupo de pacientes significa que uma tarefa de processamento separada é necessária para cada pasta do grupo de pacientes, como você pode ver na seção central do diagrama (2), em vez de uma única tarefa de processamento com várias EC2 instâncias. Como os dados do MIMIC-III incluem arquivos de forma de onda binários e arquivos de cabeçalho baseados em texto correspondentes, e há uma dependência necessária da [biblioteca wfdb](https://wfdb.readthedocs.io/en/latest/) para extração de dados binários, todos os registros de um paciente específico devem ser disponibilizados na mesma instância. A única maneira de garantir que o arquivo de cabeçalho associado a cada arquivo de forma de onda binária também esteja presente é implementar a fragmentação manual para executar cada fragmento em seu próprio trabalho de processamento e especificar `s3_data_distribution_type='FullyReplicated'` quando você define a entrada do trabalho de processamento. Como alternativa, se todos os dados estivessem disponíveis em um único diretório e não existissem dependências entre os arquivos, uma opção mais adequada seria iniciar uma única tarefa de processamento com várias EC2 instâncias e `s3_data_distribution_type='ShardedByS3Key'` especificadas. A especificação `ShardedByS3Key ` do tipo de distribuição de dados do Amazon S3 SageMaker direciona o gerenciamento automático da fragmentação de dados entre instâncias.
Iniciar uma tarefa de processamento para cada pasta é uma forma econômica de pré-processar os dados, pois a execução simultânea de várias instâncias economiza tempo. Para economizar custos e tempo adicionais, você pode usar a microfragmentação em cada tarefa de processamento.
*Microfragmentação e parallel v CPUs*
Em cada tarefa de processamento, os dados agrupados são divididos ainda mais para maximizar o uso de todos os v disponíveis CPUs na EC2 instância SageMaker totalmente gerenciada. Os blocos na seção central do diagrama (2) mostram o que acontece em cada tarefa de processamento principal. O conteúdo das pastas de registros do paciente é nivelado e dividido uniformemente com base no número de v disponíveis CPUs na instância. Depois que o conteúdo da pasta é dividido, o conjunto de arquivos de tamanho uniforme é distribuído em todos os v CPUs para processamento. Quando o processamento é concluído, os resultados de cada vCPU são combinados em um único arquivo de dados para cada tarefa de processamento.
No código em anexo, esses conceitos são representados na seção a seguir do arquivo `src/feature-engineering-pass1/preprocessing.py`.
```
def chunks(lst, n):
"""
Yield successive n-sized chunks from lst.
:param lst: list of elements to be divided
:param n: number of elements per chunk
:type lst: list
:type n: int
:return: generator comprising evenly sized chunks
:rtype: class 'generator'
"""
for i in range(0, len(lst), n):
yield lst[i:i + n]
# Generate list of data files on machine
data_dir = input_dir
d_subs = next(os.walk(os.path.join(data_dir, '.')))[1]
file_list = []
for ds in d_subs:
file_list.extend(os.listdir(os.path.join(data_dir, ds, '.')))
dat_list = [os.path.join(re.split('_|\.', f)[0].replace('n', ''), f[:-4]) for f in file_list if f[-4:] == '.dat']
# Split list of files into sub-lists
cpu_count = multiprocessing.cpu_count()
splits = int(len(dat_list) / cpu_count)
if splits == 0: splits = 1
dat_chunks = list(chunks(dat_list, splits))
# Parallelize processing of sub-lists across CPUs
ws_df_list = Parallel(n_jobs=-1, verbose=0)(delayed(run_process)(dc) for dc in dat_chunks)
# Compile and pickle patient group dataframe
ws_df_group = pd.concat(ws_df_list)
ws_df_group = ws_df_group.reset_index().rename(columns={'index': 'signal'})
ws_df_group.to_json(os.path.join(output_dir, group_data_out))
```
Uma função, `chunks`, é definida primeiro para consumir uma determinada lista dividindo-a em partes de tamanho uniforme `n ` e retornando esses resultados como um gerador. Em seguida, os dados são agrupados nas pastas dos pacientes compilando uma lista de todos os arquivos binários de forma de onda que estão presentes. Depois disso, o número de v CPUs disponível na EC2 instância é obtido. [A lista de arquivos de forma de onda binária é dividida uniformemente entre esses v CPUs por meio de uma chamada e`chunks`, em seguida, cada sublista de forma de onda é processada em sua própria vCPU usando a classe Parallel do joblib.](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html) Os resultados são combinados automaticamente em uma única lista de dataframes pelo trabalho de processamento, que SageMaker então processa ainda mais antes de gravá-los no Amazon S3 após a conclusão do trabalho. Neste exemplo, há 10 arquivos gravados no Amazon S3 pelos trabalhos de processamento (um para cada trabalho).
Quando todas as tarefas de processamento iniciais estiverem concluídas, uma tarefa de processamento secundária, mostrada no bloco à direita do diagrama (3), combina os arquivos de saída produzidos por cada tarefa de processamento principal e grava a saída combinada no Amazon S3 (4).
## Ferramentas
**Ferramentas**
+ [Python](https://www.python.org/): o código de amostra usado para esse padrão é Python (versão 3).
+ [SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) — O Amazon SageMaker Studio é um ambiente de desenvolvimento integrado (IDE) baseado na web para aprendizado de máquina que permite criar, treinar, depurar, implantar e monitorar seus modelos de aprendizado de máquina. Você executa trabalhos SageMaker de processamento usando notebooks Jupyter dentro do Studio. SageMaker
+ [SageMaker Processamento](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) — O Amazon SageMaker Processing fornece uma forma simplificada de executar suas cargas de trabalho de processamento de dados. Nesse padrão, o código de engenharia de recursos é implementado em escala usando trabalhos SageMaker de processamento.
**Código **
O arquivo .zip anexado fornece o código completo desse padrão. A seção a seguir descreve as etapas para criar a arquitetura para esse padrão. Cada etapa é ilustrada pelo código de amostra do anexo.
## Épicos
### Configure seu ambiente SageMaker Studio
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Acesse o Amazon SageMaker Studio. | Integre-se ao SageMaker Studio em sua conta da AWS seguindo as instruções fornecidas na [ SageMaker documentação da Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html). | Cientista de dados, engenheiro de ML |
| Instale o utilitário wget. | Instale o *wget* se você embarcou com uma nova configuração do SageMaker Studio ou se nunca usou esses utilitários no Studio antes. SageMaker Para instalar, abra uma janela de terminal no console do SageMaker Studio e execute o seguinte comando:sudo yum install wget
| Cientista de dados, engenheiro de ML |
| Faça download e descompacte o código de exemplo. | Faça o download do arquivo `attachments.zip` na seção *Anexos.* Em uma janela de terminal, navegue até a pasta em que você baixou o arquivo e extraia seu conteúdo:unzip attachment.zip
Navegue até a pasta em que você extraiu o arquivo .zip e extraia o conteúdo do arquivo `Scaled-Processing.zip`.unzip Scaled-Processing.zip
| Cientista de dados, engenheiro de ML |
| Faça o download do conjunto de dados de amostra em physionet.org e faça o upload para o Amazon S3. | Execute o caderno Jupyter `get_data.ipynb` dentro da pasta que contém os arquivos `Scaled-Processing`. Este notebook baixa uma amostra do conjunto de dados MIMIC-III do [physionet.org](https://physionet.org) e a carrega em seu bucket de sessão do Studio no Amazon S3. SageMaker | Cientista de dados, engenheiro de ML |
### Configurar o primeiro script de pré-processamento
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Nivele a hierarquia de arquivos em todos os subdiretórios. | Em grandes conjuntos de dados, como o MIMIC-III, os arquivos geralmente são distribuídos em vários subdiretórios, mesmo dentro de um grupo pai lógico. Seu script deve ser configurado para nivelar todos os arquivos do grupo em todos os subdiretórios, conforme demonstra o código a seguir.# Generate list of .dat files on machine
data_dir = input_dir
d_subs = next(os.walk(os.path.join(data_dir, '.')))[1]
file_list = []
for ds in d_subs:
file_list.extend(os.listdir(os.path.join(data_dir, ds, '.')))
dat_list = [os.path.join(re.split('_|\.', f)[0].replace('n', ''), f[:-4]) for f in file_list if f[-4:] == '.dat']
Os trechos de código de exemplo deste épico são do arquivo `src/feature-engineering-pass1/preprocessing.py`, que está disponível no anexo. | Cientista de dados, engenheiro de ML |
| Divida os arquivos em subgrupos com base na contagem de vCPUs. | Os arquivos devem ser divididos em subgrupos ou partes de tamanho uniforme, dependendo do número de v CPUs presente na instância que executa o script. Para esta etapa, você pode implementar um código semelhante ao seguinte.# Split list of files into sub-lists
cpu_count = multiprocessing.cpu_count()
splits = int(len(dat_list) / cpu_count)
if splits == 0: splits = 1
dat_chunks = list(chunks(dat_list, splits))
| Cientista de dados, engenheiro de ML |
| Paralelize o processamento de subgrupos em v. CPUs | A lógica do script deve ser configurada para processar todos os subgrupos em paralelo. Para fazer isso, use a classe `Parallel ` e o método `delayed ` da biblioteca Joblib da seguinte forma. # Parallelize processing of sub-lists across CPUs
ws_df_list = Parallel(n_jobs=-1, verbose=0)(delayed(run_process)(dc) for dc in dat_chunks)
| Cientista de dados, engenheiro de ML |
| Salve a saída de um único grupo de arquivos no Amazon S3. | Quando o processamento paralelo da vCPU estiver concluído, os resultados de cada vCPU deverão ser combinados e enviados para o caminho do bucket S3 do grupo de arquivos. Para esta etapa, você pode usar um código semelhante ao seguinte.# Compile and pickle patient group dataframe
ws_df_group = pd.concat(ws_df_list)
ws_df_group = ws_df_group.reset_index().rename(columns={'index': 'signal'})
ws_df_group.to_json(os.path.join(output_dir, group_data_out))
| Cientista de dados, engenheiro de ML |
### Configurar o segundo script de pré-processamento
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Combine arquivos de dados produzidos em todas as tarefas de processamento que executaram o primeiro script. | O script anterior gera um único arquivo para cada tarefa de SageMaker processamento que processa um grupo de arquivos do conjunto de dados. Em seguida, você precisa combinar esses arquivos de saída em um único objeto e gravar um único conjunto de dados de saída no Amazon S3. Isso é demonstrado no arquivo `src/feature-engineering-pass1p5/preprocessing.py`, que é fornecido no anexo, da seguinte forma.def write_parquet(wavs_df, path):
"""
Write waveform summary dataframe to S3 in parquet format.
:param wavs_df: waveform summary dataframe
:param path: S3 directory prefix
:type wavs_df: pandas dataframe
:type path: str
:return: None
"""
extra_args = {"ServerSideEncryption": "aws:kms"}
wr.s3.to_parquet(
df=wavs_df,
path=path,
compression='snappy',
s3_additional_kwargs=extra_args)
def combine_data():
"""
Get combined data and write to parquet.
:return: waveform summary dataframe
:rtype: pandas dataframe
"""
wavs_df = get_data()
wavs_df = normalize_signal_names(wavs_df)
write_parquet(wavs_df, "s3://{}/{}/{}".format(bucket_xform, dataset_prefix, pass1p5out_data))
return wavs_df
wavs_df = combine_data()
| Cientista de dados, engenheiro de ML |
### Executar tarefa de processamento
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Execute a primeira tarefa de processamento. | Para realizar a fragmentação de macros, execute uma tarefa de processamento separada para cada grupo de arquivos. A microfragmentação é executada dentro de cada tarefa de processamento, porque cada tarefa executa seu primeiro script. O código a seguir demonstra como iniciar uma tarefa de processamento para cada diretório de grupo de arquivos no trecho a seguir (incluído em `notebooks/FeatExtract_Pass1.ipynb`).pat_groups = list(range(30,40))
ts = str(int(time.time()))
for group in pat_groups:
sklearn_processor = SKLearnProcessor(framework_version='0.20.0',
role=role,
instance_type='ml.m5.4xlarge',
instance_count=1,
volume_size_in_gb=5)
sklearn_processor.run(
code='../src/feature-engineering-pass1/preprocessing.py',
job_name='-'.join(['scaled-processing-p1', str(group), ts]),
arguments=[
"input_path", "/opt/ml/processing/input",
"output_path", "/opt/ml/processing/output",
"group_data_out", "ws_df_group.json"
],
inputs=
[
ProcessingInput(
source=f's3://{sess.default_bucket()}/data_inputs/{group}',
destination='/opt/ml/processing/input',
s3_data_distribution_type='FullyReplicated'
)
],
outputs=
[
ProcessingOutput(
source='/opt/ml/processing/output',
destination=f's3://{sess.default_bucket()}/data_outputs/{group}'
)
],
wait=False
)
| Cientista de dados, engenheiro de ML |
| Execute a segunda tarefa de processamento. | Para combinar as saídas geradas pelo primeiro conjunto de trabalhos de processamento e realizar quaisquer cálculos adicionais para pré-processamento, você executa seu segundo script usando um único SageMaker trabalho de processamento. O código a seguir demonstra isso (incluído em `notebooks/FeatExtract_Pass1p5.ipynb`).ts = str(int(time.time()))
bucket = sess.default_bucket()
sklearn_processor = SKLearnProcessor(framework_version='0.20.0',
role=role,
instance_type='ml.t3.2xlarge',
instance_count=1,
volume_size_in_gb=5)
sklearn_processor.run(
code='../src/feature-engineering-pass1p5/preprocessing.py',
job_name='-'.join(['scaled-processing', 'p1p5', ts]),
arguments=['bucket', bucket,
'pass1out_prefix', 'data_outputs',
'pass1out_data', 'ws_df_group.json',
'pass1p5out_data', 'waveform_summary.parquet',
'statsdata_name', 'signal_stats.csv'],
wait=True
)
| Cientista de dados, engenheiro de ML |
## Recursos relacionados
+ [Integre-se ao Amazon SageMaker Studio usando o Quick Start](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) (SageMaker documentação)
+ [Dados do processo](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) (SageMaker documentação)
+ [Processamento de dados com scikit-learn (documentação](https://docs.aws.amazon.com/sagemaker/latest/dg/use-scikit-learn-processing-container.html)) SageMaker
+ [Documentação do joblib.PARALLEL](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html)
+ Moody, B., Moody, G., Villarroel, M., Clifford, G. D. e Silva, I. (2020). Banco de [dados de formas de onda MIMIC-III (versão](https://doi.org/10.13026/c2607m) 1.0). *PhysioNet*.
+ Johnson, A. E. W., Pollard, T.J., Shen, L., Lehman, L. H., Feng, M., Ghassemi, M., Moody, B., Szolovits, P., Celi, L. A. e Mark, R.G. (2016). [MIMIC-III, um banco de dados de cuidados intensivos de acesso gratuito](https://dx.doi.org/10.1038/sdata.2016.35). Dados científicos, 3, 160035.
+ [Licença do banco de dados MIMIC-III Waveform](https://physionet.org/content/mimic3wdb/1.0/LICENSE.txt)
## Anexos
Para acessar o conteúdo adicional associado a este documento, descompacte o seguinte arquivo: [ attachment.zip](samples/p-attach/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/attachments/attachment.zip)
# Visualize os resultados do AI/ML modelo usando o Flask e o AWS Elastic Beanstalk
*Chris Caudill e Durga Sury, Amazon Web Services*
## Resumo
A visualização do resultado dos serviços de inteligência artificial e machine learning (IA/ML) geralmente exige chamadas de API complexas que devem ser personalizadas por seus desenvolvedores e engenheiros. Isso pode ser uma desvantagem se seus analistas quiserem explorar rapidamente um novo conjunto de dados.
Você pode aprimorar a acessibilidade de seus serviços e fornecer uma forma mais interativa de análise de dados usando uma interface de usuário (UI) baseada na web que permite que os usuários carreguem seus próprios dados e visualizem os resultados do modelo em um painel.
Esse padrão usa [Flask](https://flask.palletsprojects.com/en/2.0.x/) e [Plotly](https://plotly.com/) para integrar o Amazon Comprehend a um aplicativo web personalizado e visualizar sentimentos e entidades a partir de dados fornecidos pelo usuário. O padrão também fornece as etapas para implantar um aplicativo usando o AWS Elastic Beanstalk. Você pode adaptar o aplicativo usando os serviços de [IA da Amazon Web Services (AWS)](https://aws.amazon.com/machine-learning/ai-services/) ou com um modelo personalizado treinado hospedado em um endpoint (por exemplo, um [ SageMaker endpoint da Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html)).
## Pré-requisitos e limitações
**Pré-requisitos **
+ Uma conta AWS ativa
+ AWS Command Line Interface (AWS CLI), instalada e configurada na sua máquina local. Para obter mais informações, consulte [Noções básicas de configuração](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) na documentação da AWS CLI. Você também pode usar um ambiente de desenvolvimento integrado (IDE) do AWS Cloud9; para obter mais informações a respeito, consulte [Tutorial do Python para o AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/sample-python.html) e [Visualização de aplicativos em execução no IDE do AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html) na documentação do AWS Cloud9.
**Aviso**: não AWS Cloud9 está mais disponível para novos clientes. Os clientes existentes do AWS Cloud9 podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
+ Uma compreensão da estrutura de aplicativos web do Flask. Para obter mais informações sobre o Flask, consulte [Início rápido](https://flask.palletsprojects.com/en/1.1.x/quickstart) na documentação do Flask.
+ A versão 3.6 ou superior do Python está instalada e configurada. Você pode instalar o Python seguindo as instruções em [Configuração de seu ambiente de desenvolvimento em Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html) na documentação do AWS Elastic Beanstalk.
+ Interface de linha de comando do Elastic Beanstalk (CLI do EB) instalada e configurada. Para obter mais informações a respeito, consulte [Instalar a EB CLI](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-install.html) e [Configurar a EB CLI](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-configuration.html) na documentação do AWS Elastic Beanstalk.
**Limitações**
+ O aplicativo Flask deste padrão foi desenvolvido para funcionar com arquivos .csv que usam uma única coluna de texto e estão restritos a 200 linhas. O código do aplicativo pode ser adaptado para lidar com outros tipos de arquivos e volumes de dados.
+ O aplicativo não considera a retenção de dados e continua agregando arquivos de usuário enviados até que eles sejam excluídos manualmente. Você pode integrar o aplicativo ao Amazon Simple Storage Service (Amazon S3) para armazenamento persistente de objetos ou usar um banco de dados como o Amazon DynamoDB para armazenamento de valores-chave de tecnologia sem servidor.
+ O aplicativo considera apenas documentos no idioma inglês. No entanto, você pode usar o Amazon Comprehend para detectar o idioma principal de um documento. Para obter mais informações sobre os idiomas compatíveis para cada ação, consulte a [Referência de APIs](https://docs.aws.amazon.com/comprehend/latest/dg/API_Reference.html) na documentação do Amazon Comprehend.
+ Uma lista de solução de problemas que contém erros comuns e suas soluções está disponível na seção *Informações adicionais*.
## Arquitetura
**Arquitetura do aplicativo Flask**
O Flask é uma estrutura leve para o desenvolvimento de aplicativos web em Python. Ele foi projetado para combinar o poderoso processamento de dados do Python com uma rica interface de usuário da web. O aplicativo Flask do padrão mostra como criar um aplicativo web que permite aos usuários fazer upload de dados, enviar os dados para o Amazon Comprehend para inferência e, em seguida, visualizar os resultados. O aplicativo possui a seguinte estrutura:
+ `static`— Contém todos os arquivos estáticos que suportam a interface do usuário da web (por exemplo JavaScript, CSS e imagens)
+ `templates`: contém todas as páginas HTML do aplicativo
+ `userData`: armazena dados do usuário enviados
+ `application.py`: o arquivo do aplicativo Flask
+ `comprehend_helper.py`: funções para fazer chamadas de API para o Amazon Comprehend
+ `config.py`: o arquivo de configuração de aplicativo
+ `requirements.txt`: as dependências do Python exigidas pelo aplicativo
O script `application.py` contém a funcionalidade principal do aplicativo web, que consiste em quatro rotas do Flask. O diagrama a seguir mostra essas rotas do Flask.
![\[As quatro rotas do Flask que compõem a funcionalidade principal da aplicação web.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/9ca6bad1-26e2-4262-98d0-d54c172336bf.png)
+ `/` é a raiz do aplicativo e direciona os usuários para a página `upload.html` (armazenada no diretório `templates`).
+ `/saveFile` é uma rota invocada depois que um usuário carrega um arquivo. Essa rota recebe uma solicitação `POST` por meio de um formulário HTML, que contém o arquivo enviado pelo usuário. O arquivo é salvo no diretório `userData` e a rota redireciona os usuários para a rota `/dashboard`.
+ `/dashboard` envia os usuários para a página `dashboard.html`. No HTML dessa página, ele executa o JavaScript código `static/js/core.js` que lê os dados da `/data` rota e, em seguida, cria visualizações para a página.
+ `/data` é uma API JSON que apresenta os dados a serem visualizados no painel. Esta rota lê os dados fornecidos pelo usuário e usa as funções em `comprehend_helper.py` para enviar os dados do usuário ao Amazon Comprehend visando à análise de sentimentos e ao reconhecimento de entidade nomeada (NER). A resposta do Amazon Comprehend é formatada e retornada como um objeto JSON.
**Arquitetura de implantação**
![\[Diagrama de arquitetura para usar o Flask e o Elastic AI/ML Beanstalk para visualizar os resultados do modelo.\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/d691bfd2-e2ec-4830-8bff-ffa1e3a95c4a.png)
[Considerações sobre design](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.concepts.design.html)
Para obter mais informações sobre considerações de design para aplicações implantados usando o Elastic Beanstalk na Nuvem AWS, consulte a documentação do AWS Elastic Beanstalk.
**Pilha de tecnologia**
+ Amazon Comprehend
+ Elastic Beanstalk
+ Flask
**Automação e escala**
As implantações do Elastic Beanstalk são configuradas automaticamente com balanceadores de carga e grupos do Auto Scaling. Para obter mais opções de configuração, consulte [Configuração dos ambientes do Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html) na documentação do AWS Elastic Beanstalk.
## Ferramentas
+ A [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) é uma ferramenta unificada que fornece uma interface consistente para interagir com todas as partes da AWS.
+ O [Amazon Comprehend](https://docs.aws.amazon.com/comprehend/latest/dg/comprehend-general.html) usa o processamento de linguagem natural (PLN) para extrair insights sobre o conteúdo dos documentos sem demandar pré-processamento especial.
+ O [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html) ajuda a implantar e gerenciar rapidamente aplicações na Nuvem AWS sem se preocupar com a infraestrutura que executa esses aplicações.
+ O [Elastic Beanstalk CLI (EB CLI)](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3.html) é uma interface da linha de comando para o AWS Elastic Beanstalk que fornece comandos interativos que simplificam a criação, a atualização e o monitoramento de ambientes por meio de um repositório local.
+ A estrutura [Flask](https://flask.palletsprojects.com/en/2.0.x/) executa o processamento de dados e chamadas de API usando Python e oferece visualização web interativa com o Plotly.
**Código**
O código desse padrão está disponível nos [resultados do AI/ML modelo GitHub Visualize usando o Flask e o repositório AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask).
## Épicos
### Configurar o aplicativo Flask
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Clone o GitHub repositório. | Extraia o código do aplicativo dos [resultados do AI/ML modelo GitHub Visualize usando o Flask e o repositório AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) executando o seguinte comando:`git clone git@github.com:aws-samples/aws-comprehend-elasticbeanstalk-for-flask.git`Certifique-se de configurar suas chaves SSH com GitHub. | Desenvolvedor |
| Instale os módulos do Python. | Depois de clonar o repositório, um novo diretório `aws-comprehend-elasticbeanstalk-for-flask` local é criado. Nesse diretório, o arquivo `requirements.txt` contém os módulos e versões do Python que executam o aplicativo. Use o comando a seguir para instalar os módulos:`cd aws-comprehend-elasticbeanstalk-for-flask``pip install -r requirements.txt` | Desenvolvedor de Python |
| Testar o aplicativo localmente. | Execute o comando a seguir para iniciar o servidor do Flask:`python application.py`Isso retorna informações sobre o servidor em execução. Você deve conseguir acessar o aplicativo abrindo um navegador e visitando http://localhost:5000Se você estiver executando a aplicação em um IDE do AWS Cloud9, precisará substituir o comando `application.run()` no arquivo `application.py` pela seguinte linha:`application.run(host=os.getenv('IP', '0.0.0.0'),port=int(os.getenv('PORT', 8080)))`Você deve reverter essa alteração antes da implantação. | Desenvolvedor de Python |
### Implante o aplicativo no Elastic Beanstalk
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Inicie o aplicativo do Elastic Beanstalk. | Para iniciar seu projeto como um aplicativo do Elastic Beanstalk, execute o seguinte comando no diretório raiz do seu aplicativo:`eb init -p python-3.6 comprehend_flask --region us-east-1`[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html)Execute o comando `eb init -i` para obter mais opções de configuração de implantação. | Arquiteto, desenvolvedor |
| Configure o ambiente do Elastic Beanstalk. | Execute o comando a seguir do diretório raiz do aplicativo:`eb create comprehend-flask-env``comprehend-flask-env` é o nome do ambiente do Elastic Beanstalk e pode ser alterado de acordo com seus requisitos. O nome pode conter somente letras, números e hifens. | Arquiteto, desenvolvedor |
| Autorize sua implantação para usar o Amazon Comprehend. | Embora seu aplicativo possa ser implantado com sucesso, você também deve fornecer à sua implantação acesso ao Amazon Comprehend. `ComprehendFullAccess` é uma política gerenciada pela AWS que fornece ao aplicativo implantado permissões para fazer chamadas de API para o Amazon Comprehend.Anexe a política `ComprehendFullAccess` a `aws-elasticbeanstalk-ec2-role` (essa função é criada automaticamente para as instâncias do Amazon Elastic Compute Cloud (Amazon EC2) da sua implantação) executando o seguinte comando:`aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ComprehendFullAccess --role-name aws-elasticbeanstalk-ec2-role`O `aws-elasticbeanstalk-ec2-role` é criado quanda sua aplicação é implantada. É necessário concluir o processo de implantação antes que seja possível anexar a política do AWS Identity and Access Management (IAM). | Desenvolvedor, arquiteto de segurança |
| Visite seu aplicativo implantado. | Depois que seu aplicativo for implantado com sucesso, você poderá visitá-lo executando o comando `eb open`.Você também pode executar o comando `eb status` para obter detalhes sobre sua implantação. O URL de implantação está sob `CNAME`. | Arquiteto, desenvolvedor |
### (Opcional) Personalize o aplicativo de acordo com seu modelo de ML
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Autorize o Elastic Beanstalk a acessar o novo modelo. | Certifique-se de que o Elastic Beanstalk tenha as permissões de acesso necessárias para seu novo modelo de endpoint. Por exemplo, se você usa um SageMaker endpoint da Amazon, sua implantação precisa ter permissão para invocar o endpoint. Para obter mais informações sobre isso, consulte [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)a SageMaker documentação da Amazon. | Desenvolvedor, arquiteto de segurança |
| Envie os dados do usuário para um novo modelo. | Para alterar o modelo de ML subjacente nesse aplicativo, você deve alterar os seguintes arquivos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Cientista de dados |
| Atualize as visualizações do painel. | Normalmente, com a incorporação de um novo modelo de ML, as visualizações devem ser atualizadas para refletir os novos resultados. As alterações a seguir são feitas nos seguintes arquivos:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Desenvolvedor web |
### (Opcional) Implante o aplicativo atualizado
| Tarefa | Description | Habilidades necessárias |
| --- | --- | --- |
| Atualize o arquivo de requisitos do seu aplicativo. | Antes de enviar alterações para o Elastic Beanstalk, atualize o arquivo `requirements.txt` para refletir quaisquer novos módulos do Python executando o seguinte comando no diretório raiz do seu aplicativo:`pip freeze > requirements.txt` | Desenvolvedor de Python |
| Configure o ambiente do Elastic Beanstalk. | Para garantir que as alterações do seu aplicativo sejam refletidas na implantação do Elastic Beanstalk, navegue até o diretório raiz do seu aplicativo e execute o seguinte comando:`eb deploy`Essa ação envia a versão mais recente do código do aplicativo para sua implantação existente do Elastic Beanstalk. | Administrador de sistemas, arquiteto |
## Recursos relacionados
+ [Chame um endpoint SageMaker modelo da Amazon usando o Amazon API Gateway e o AWS Lambda](https://aws.amazon.com/blogs/machine-learning/call-an-amazon-sagemaker-model-endpoint-using-amazon-api-gateway-and-aws-lambda/)
+ [Implantar uma aplicação Flask no Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html)
+ [Referência de comandos da EB CLI ](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb3-cmd-commands.html)
+ [Configurar seu ambiente de desenvolvimento Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html)
## Mais informações
**Lista de solução de problemas**
Veja a seguir seis erros comuns e suas soluções.
***Erro 1 * **
```
Unable to assume role "arn:aws:iam::xxxxxxxxxx:role/aws-elasticbeanstalk-ec2-role". Verify that the role exists and is configured correctly.
```
**Solução**: se esse erro ocorrer durante a execução de `eb create`, crie um aplicativo de amostra no console do Elastic Beanstalk para desenvolver o perfil de instância padrão. Para obter mais informações a respeito, consulte [Criação de um ambiente do Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.environments.html) na documentação do AWS Elastic Beanstalk.
***Erro 2***
```
Your WSGIPath refers to a file that does not exist.
```
**Solução: **esse erro ocorre nos logs de implantação porque o Elastic Beanstalk espera que o código do Flask seja nomeado como `application.py`. Se você escolher um nome diferente, execute `eb config` e edite o WSGIPath conforme mostrado no exemplo de código a seguir:
```
aws:elasticbeanstalk:container:python:
NumProcesses: '1'
NumThreads: '15'
StaticFiles: /static/=static/
WSGIPath: application.py
```
Certifique-se de substituir `application.py` pelo nome do seu arquivo.
Você também pode utilizar o Gunicorn e um Procfile. Para obter mais informações sobre essa abordagem, consulte [Configuração do servidor WSGI com um Procfile](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-configuration-procfile.html) na documentação do AWS Elastic Beanstalk.
***Erro 3***
```
Target WSGI script '/opt/python/current/app/application.py' does not contain WSGI application 'application'.
```
**Solução: **o Elastic Beanstalk espera que a variável que representa seu aplicativo Flask seja nomeada como `application`. Certifique-se de que o arquivo `application.py` use `application` como nome da variável:
```
application = Flask(__name__)
```
***Erro 4***
```
The EB CLI cannot find your SSH key file for keyname
```
**Solução:** use a EB CLI para especificar qual par de chaves usar ou para criar um par de chaves para as instâncias do EC2 da sua implantação. Para resolver o erro, execute `eb init -i` e uma das opções perguntará:
```
Do you want to set up SSH for your instances?
```
Responda com `Y` para criar um par de chaves ou especificar um par de chaves existente.
***Erro 5***
*Eu atualizei e reimplantei meu código, mas minha implantação não está refletindo minhas alterações.*
**Solução**: se você estiver usando um repositório Git com sua implantação, certifique-se de adicionar e confirmar suas alterações antes da reimplantação.
***Erro 6***
*Você está visualizando o aplicativo Flask a partir de um IDE do AWS Cloud9 e se depara com erros.*
**Solução: **para obter mais informações a respeito, consulte [Visualização de aplicativos em execução no IDE do AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html) na documentação do AWS Cloud9.
**Usar o Amazon Comprehend para processamento de linguagem natural**
Ao optar pelo Amazon Comprehend, você pode detectar entidades personalizadas em documentos de texto individuais executando análises em tempo real ou tarefas em lotes assíncronos. O Amazon Comprehend também permite que você treine modelos personalizados de reconhecimento de entidades e de classificação de texto que podem ser usados em tempo real criando um endpoint.
Esse padrão usa tarefas em lotes assíncronos para detectar sentimentos e entidades a partir de um arquivo de entrada que contém vários documentos. O aplicativo de amostra fornecido por esse padrão foi projetado para que os usuários façam upload de um arquivo .csv contendo uma única coluna com um documento de texto por linha. O `comprehend_helper.py` arquivo nos [resultados do AI/ML modelo GitHub Visualize usando o Flask e o repositório AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) lê o arquivo de entrada e envia a entrada para o Amazon Comprehend para processamento.
*BatchDetectEntities*
O Amazon Comprehend inspeciona o texto de um lote de documentos em busca de entidades nomeadas e retorna a entidade detectada, a localização, o [tipo de entidade](https://docs.aws.amazon.com/comprehend/latest/dg/how-entities.html) e uma pontuação que indica o nível de confiança do Amazon Comprehend. No máximo 25 documentos podem ser enviados em uma chamada de API, sendo que cada documento deve ter até 5.000 bytes. Você pode filtrar os resultados para mostrar somente determinadas entidades com base no caso de uso. Por exemplo, você pode ignorar o tipo de entidade `‘quantity’` e definir uma pontuação limite para a entidade detectada (por exemplo, 0,75). Recomendamos que você explore os resultados para seu caso de uso específico antes de escolher um valor limite. Para obter mais informações sobre isso, consulte a [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectEntities.html)documentação do Amazon Comprehend.
*BatchDetectSentiment*
O Amazon Comprehend inspeciona um lote de documentos recebidos e retorna o sentimento predominante de cada documento (`POSITIVE`, `NEUTRAL`, `MIXED` ou `NEGATIVE`). No máximo 25 documentos podem ser enviados em uma chamada de API, sendo que cada documento deve ter até 5.000 bytes. Analisar o sentimento é simples e você escolhe o sentimento com a pontuação mais alta para ser exibido nos resultados finais. Para obter mais informações sobre isso, consulte a [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectSentiment.html)documentação do Amazon Comprehend.
**Processamento de configuração do Flask**
Os servidores Flask usam uma série de [variáveis de configuração](https://flask.palletsprojects.com/en/1.1.x/config/) para controlar sua execução. Essas variáveis podem conter resultados de depuração, tokens de sessão ou outras configurações do aplicativo. Também é possível definir variáveis personalizadas que podem ser acessadas enquanto o aplicativo está em execução. Há várias abordagens para definir variáveis de configuração.
Nesse padrão, a configuração é definida em `config.py` e herdada em `application.py`.
+
**nota**
`config.py` contém as variáveis de configuração definidas no startup do aplicativo. Nesse aplicativo, uma variável `DEBUG` é definida para instruir o aplicativo a executar o servidor no [modo de depuração](https://flask.palletsprojects.com/en/1.1.x/config/#DEBUG). : o modo de depuração não deve ser usado ao executar uma aplicação em um ambiente de produção. `UPLOAD_FOLDER` é uma variável personalizada definida para ser referenciada posteriormente na aplicação e informá-lo onde os dados do usuário enviados devem ser armazenados.
+ `application.py` inicia o aplicativo Flask e herda as configurações definidas em `config.py`. Isso é realizado pelo seguinte código:
```
application = Flask(__name__)
application.config.from_pyfile('config.py')
```
# Mais padrões
**Topics**
+ [Acelere MLOps com os modelos de Backstage e de autoatendimento da Amazon AI SageMaker](accelerate-mlops-with-backstage-and-sagemaker-templates.md)
+ [Automatize as operações de AWS infraestrutura usando o Amazon Bedrock](automate-aws-infrastructure-operations-by-using-amazon-bedrock.md)
+ [Implantação de sistemas agênticos no Amazon Bedrock com a estrutura do CrewAI usando o Terraform](deploy-agentic-systems-on-amazon-bedrock-with-the-crewai-framework.md)
+ [Implemente uma ChatOps solução para gerenciar os resultados do escaneamento SAST usando o Amazon Q Developer em aplicativos de bate-papo, ações personalizadas e CloudFormation](deploy-chatops-solution-to-manage-sast-scan-results.md)
+ [Gere insights de dados usando o AWS Mainframe Modernization Amazon Q no Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Gere insights de z/OS dados do Db2 usando o AWS Mainframe Modernization Amazon Q no Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Conceda às instâncias do SageMaker notebook acesso temporário a um CodeCommit repositório em outra conta da AWS](give-sagemaker-notebook-instances-temporary-access-to-a-codecommit-repository-in-another-aws-account.md)
+ [Gerencie AWS Organizations políticas como código usando o AWS CodePipeline Amazon Bedrock](manage-organizations-policies-as-code.md)
+ [Modernize o aplicativo de CardDemo mainframe usando AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernize e implante aplicativos de mainframe usando o Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Execute análises avançadas usando o Amazon Redshift ML](perform-advanced-analytics-using-amazon-redshift-ml.md)
+ [Simplifique o gerenciamento de EC2 conformidade da Amazon com agentes do Amazon Bedrock e AWS Config](streamline-amazon-ec2-compliance-management-with-amazon-bedrock-agents-and-aws-config.md)
+ [Desenvolvimento e implantação simplificados de bots do Amazon Lex usando um fluxo de trabalho automatizado](streamline-amazon-lex-bot-development-and-deployment-using-an-automated-workflow.md)
+ [Solucione problemas de estados AWS Step Functions usando o Amazon Bedrock](troubleshooting-states-in-aws-step-functions.md)