`, ruft eine [Amazon S3 S3-Benachrichtigung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html) die Lambda-Funktion auf. `data-ingestion-processor`
1. Die Lambda-Funktion `data-ingestion-processor` basiert auf einem Docker-Image, das im Amazon Elastic Container Registry (Amazon ECR) -Repository gespeichert ist. `bedrock-rag-template`
[Die Funktion verwendet [LangChain S3](https://python.langchain.com/v0.1/docs/integrations/document_loaders/aws_s3_file/), FileLoader um die Datei als Dokument zu lesen. LangChain ](https://api.python.langchain.com/en/v0.0.339/schema/langchain.schema.document.Document.html) Dann werden die [LangChain RecursiveCharacterTextSplitter](https://python.langchain.com/v0.1/docs/modules/data_connection/document_transformers/recursive_text_splitter/)Chunks jedes Dokument mit a `CHUNK_SIZE` und a versehen, `CHUNK_OVERLAP` die von der maximalen Token-Größe des Amazon Titan Text Embedding V2-Einbettungsmodells abhängen. Als Nächstes ruft die Lambda-Funktion das Einbettungsmodell auf Amazon Bedrock auf, um die Chunks in numerische Vektordarstellungen einzubetten. Schließlich werden diese Vektoren in der Aurora PostgreSQL-Datenbank gespeichert. Um auf die Datenbank zuzugreifen, ruft die Lambda-Funktion zunächst den Benutzernamen und das Passwort von ab. AWS Secrets Manager
1. Auf der Amazon SageMaker [AI-Notebook-Instance](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) `aws-sample-bedrock-rag-template` kann der Benutzer eine Fragenaufforderung schreiben. Der Code ruft Claude 3 auf Amazon Bedrock auf und fügt die Wissensdatenbankinformationen dem Kontext der Aufforderung hinzu. Infolgedessen gibt Claude 3 Antworten unter Verwendung der Informationen in den Dokumenten.
Der Ansatz dieses Musters in Bezug auf Netzwerk und Sicherheit lautet wie folgt:
+ Die Lambda-Funktion `data-ingestion-processor` befindet sich in einem privaten Subnetz innerhalb der Virtual Private Cloud (VPC). Die Lambda-Funktion darf aufgrund ihrer Sicherheitsgruppe keinen Datenverkehr an das öffentliche Internet senden. Daher wird der Datenverkehr zu Amazon S3 und Amazon Bedrock nur über die VPC-Endpunkte geleitet. Folglich durchquert der Datenverkehr nicht das öffentliche Internet, was die Latenz reduziert und eine zusätzliche Sicherheitsebene auf Netzwerkebene bietet.
+ Alle Ressourcen und Daten werden, wann immer möglich, verschlüsselt, indem der Schlüssel AWS Key Management Service (AWS KMS) zusammen mit dem Alias `aws-sample/bedrock-rag-template` verwendet wird.
**Automatisierung und Skalierung**
Dieses Muster verwendet Terraform, um die Infrastruktur aus dem Code-Repository in einem bereitzustellen. AWS-Konto
## Tools
**AWS-Services**
+ [Amazon Aurora PostgreSQL-Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) ist eine vollständig verwaltete, ACID-konforme relationale Datenbank-Engine, die Sie bei der Einrichtung, dem Betrieb und der Skalierung von PostgreSQL-Bereitstellungen unterstützt. In diesem Muster verwendet Aurora PostgreSQL-kompatibel das pgvector-Plugin als Vektordatenbank.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) ist ein vollständig verwalteter Service, der Ihnen leistungsstarke Basismodelle (FMs) von führenden KI-Startups und Amazon über eine einheitliche API zur Verfügung stellt.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können.
+ [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist. In diesem Muster hostet Amazon ECR das Docker-Image für die `data-ingestion-processor` Lambda-Funktion.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) hilft Ihnen dabei, den Zugriff auf Ihre AWS Ressourcen sicher zu verwalten, indem kontrolliert wird, wer authentifiziert und autorisiert ist, diese zu verwenden.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) hilft Ihnen dabei, kryptografische Schlüssel zu erstellen und zu kontrollieren, um Ihre Daten zu schützen.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen. In diesem Muster nimmt Lambda Daten in den Vektorspeicher auf.
+ [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) ist ein verwalteter Service für maschinelles Lernen (ML), mit dem Sie ML-Modelle erstellen und trainieren und diese dann in einer produktionsbereiten, gehosteten Umgebung bereitstellen können.
+ Mit [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) können Sie fest codierte Anmeldeinformationen im Code (einschließlich Passwörter) durch einen API-Aufruf an Secrets Manager ersetzen und das Geheimnis programmgesteuert abrufen.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
+ [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) hilft Ihnen dabei, AWS Ressourcen in einem von Ihnen definierten virtuellen Netzwerk bereitzustellen. Dieses virtuelle Netzwerk entspricht einem herkömmlichen Netzwerk, wie Sie es in Ihrem Rechenzentrum betreiben würden, mit den Vorteilen der Verwendung der skalierbaren Infrastruktur von AWS. Die VPC umfasst Subnetze und Routingtabellen zur Steuerung des Datenverkehrs.
**Andere Tools**
+ [Docker](https://docs.docker.com/manuals/) ist eine Reihe von Platform-as-a-Service (PaaS) -Produkten, die Virtualisierung auf Betriebssystemebene nutzen, um Software in Containern bereitzustellen.
+ [HashiCorp Terraform](https://www.terraform.io/docs) ist ein Infrastructure-as-Code-Tool (IaC), mit dem Sie mithilfe von Code Cloud-Infrastruktur und -Ressourcen bereitstellen und verwalten können.
+ [Poetry](https://pypi.org/project/poetry/) ist ein Tool für Abhängigkeitsmanagement und Paketierung in Python.
+ [Python](https://www.python.org/) ist eine Allzweck-Computerprogrammiersprache.
**Code-Repository**
Der Code für dieses Muster ist im Repository GitHub [terraform-rag-template-using-amazon-bedrock](https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock) verfügbar.
## Best Practices
+ Dieses Codebeispiel kann zwar in allen Bereichen eingesetzt werden AWS-Region, wir empfehlen jedoch, dass Sie US East (Nord-Virginia) — `us-east-1` oder US West (Nordkalifornien) — verwenden. `us-west-1` Diese Empfehlung basiert auf der Verfügbarkeit von Fundament- und Einbettungsmodellen in Amazon Bedrock zum Zeitpunkt der Veröffentlichung dieses Musters. Eine up-to-date Liste der Amazon Bedrock Foundation-Modellunterstützung finden Sie unter [Model Support von AWS-Region](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) in der Amazon Bedrock-Dokumentation. AWS-Regionen Informationen zur Bereitstellung dieses Codebeispiels in anderen Regionen finden Sie unter [Zusätzliche](#deploy-rag-use-case-on-aws-additional) Informationen.
+ Dieses Muster bietet nur eine proof-of-concept (PoC) oder Pilotdemo. Wenn Sie den Code für die Produktion verwenden möchten, sollten Sie unbedingt die folgenden bewährten Methoden anwenden:
+ Aktivieren Sie die Serverzugriffsprotokollierung für Amazon S3.
+ Richten Sie die [Überwachung und Warnung](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html) für die Lambda-Funktion ein.
+ Wenn Ihr Anwendungsfall eine API erfordert, sollten Sie erwägen, Amazon API Gateway mit einer Lambda-Funktion hinzuzufügen, die Abruf- und Fragenbeantwortungsaufgaben ausführt.
+ Folgen Sie dem Prinzip der geringsten Rechte und gewähren Sie die für die Ausführung einer Aufgabe erforderlichen Mindestberechtigungen. Weitere Informationen finden Sie in der IAM-Dokumentation unter [Gewährung der geringsten Rechte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) und [bewährte Methoden zur Sicherheit](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html).
## Epen
### Stellen Sie die Lösung in einem bereit AWS-Konto
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das Repository | Verwenden Sie den folgenden Befehl, um das mit diesem Muster bereitgestellte GitHub Repository zu klonen:git clone https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock
| AWS DevOps |
| Konfigurieren Sie die Variablen. | Gehen Sie wie folgt vor, um die Parameter für dieses Muster zu konfigurieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | AWS DevOps |
| Stellen Sie die Lösung bereit. | Gehen Sie wie folgt vor, um die Lösung bereitzustellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)Die Infrastrukturbereitstellung stellt eine SageMaker KI-Instanz innerhalb der VPC bereit und verfügt über die Berechtigungen für den Zugriff auf die Aurora PostgreSQL-Datenbank. | AWS DevOps |
### Testen der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie die Demo aus. | Nachdem die vorherige Infrastrukturbereitstellung erfolgreich war, führen Sie die folgenden Schritte aus, um die Demo in einem Jupyter-Notebook auszuführen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)Das Jupyter-Notizbuch führt Sie durch den folgenden Prozess:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | Allgemeines AWS |
### Infrastruktur aufräumen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Säubere die Infrastruktur. | Verwenden Sie den folgenden Befehl, um alle Ressourcen zu entfernen, die Sie erstellt haben, als sie nicht mehr benötigt werden:terraform destroy -var-file=commons.tfvars
| AWS DevOps |
## Zugehörige Ressourcen
**AWS Ressourcen**
+ [Lambda-Funktionen mit Python erstellen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Inferenzparameter für Fundamentmodelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Zugriff auf Amazon Bedrock Foundation-Modelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Die Rolle von Vektordatenbanken in generativen KI-Anwendungen](https://aws.amazon.com/blogs/database/the-role-of-vector-datastores-in-generative-ai-applications/) (AWS Datenbank-Blog)
+ [Arbeiten mit Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html)
**Sonstige Ressourcen**
+ [pgvector-Dokumentation](https://github.com/pgvector/pgvector)
## Zusätzliche Informationen
**Implementierung einer Vektor-Datenbank**
Dieses Muster verwendet Aurora PostgreSQL-kompatibel, um eine Vektordatenbank für RAG zu implementieren. Als Alternative zu Aurora PostgreSQL AWS bietet es weitere Funktionen und Dienste für RAG, wie Amazon Bedrock Knowledge Bases und Amazon Service. OpenSearch Sie können die Lösung wählen, die Ihren spezifischen Anforderungen am besten entspricht:
+ [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) bietet verteilte Such- und Analyse-Engines, mit denen Sie große Datenmengen speichern und abfragen können.
+ [Amazon Bedrock Knowledge Bases](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) wurde für den Aufbau und die Bereitstellung von Wissensdatenbanken als zusätzliche Abstraktion entwickelt, um den RAG-Aufnahme- und Abrufprozess zu vereinfachen. Amazon Bedrock Knowledge Bases kann sowohl mit Aurora PostgreSQL als auch mit Amazon Service verwendet werden. OpenSearch
**Bereitstellung auf anderen AWS-Regionen**
Wie unter [Architektur](#deploy-rag-use-case-on-aws-architecture) beschrieben, empfehlen wir, für die Bereitstellung dieses Codebeispiels entweder die Region USA Ost (Nord-Virginia) `us-east-1` oder USA West (Nordkalifornien) `us-west-1` zu verwenden. Es gibt jedoch zwei Möglichkeiten, dieses Codebeispiel in anderen Regionen als `us-east-1` und bereitzustellen`us-west-1`. Sie können die Bereitstellungsregion in der `commons.tfvars` Datei konfigurieren. Für den regionsübergreifenden Zugriff auf das Foundation-Modell sollten Sie die folgenden Optionen in Betracht ziehen:
+ **Durchqueren des öffentlichen Internets** — Wenn der Datenverkehr das öffentliche Internet durchqueren kann, fügen Sie der VPC Internet-Gateways hinzu. Passen Sie dann die Sicherheitsgruppe an, die der Lambda-Funktion `data-ingestion-processor` und der SageMaker AI-Notebook-Instanz zugewiesen ist, um ausgehenden Datenverkehr in das öffentliche Internet zuzulassen.
+ **Kein Durchqueren des öffentlichen Internets — Gehen** Sie wie folgt vor, um dieses Beispiel in einer anderen Region als `us-east-1` oder `us-west-1` bereitzustellen:
1. Erstellen Sie entweder in der `us-west-1` Region `us-east-1` oder eine zusätzliche VPC, einschließlich eines VPC-Endpunkts für. `bedrock-runtime`
1. Stellen Sie mithilfe von [VPC-Peering oder einem [Transit-Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) eine Peering-Verbindung zur Anwendungs-VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) her.
1. Wenn Sie den `bedrock-runtime` boto3-Client in einer beliebigen Lambda-Funktion außerhalb von `us-east-1` oder konfigurieren`us-west-1`, übergeben Sie den privaten DNS-Namen des VPC-Endpunkts für `bedrock-runtime` in `us-east-1` oder us-west-1 als den an den boto3-Client. `endpoint_url`
# Stellen Sie mithilfe einer Inferenz-Pipeline in Amazon Vorverarbeitungslogik in einem ML-Modell an einem einzigen Endpunkt bereit SageMaker
*Mohan Gowda Purushothama, Gabriel Rodríguez Garcia und Mateusz Zaremba, Amazon Web Services*
## Zusammenfassung
Dieses Muster erklärt, wie mehrere Pipeline-Modellobjekte in einem einzigen Endpunkt mithilfe einer [Inferenz-Pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) in Amazon SageMaker bereitgestellt werden. Das Pipeline-Modellobjekt repräsentiert verschiedene Workflow-Phasen des maschinellen Lernens (ML), wie Vorverarbeitung, Modellinferenz und Nachverarbeitung. [Um den Einsatz von seriell verbundenen Pipeline-Modellobjekten zu veranschaulichen, zeigt Ihnen dieses Muster, wie Sie einen [Scikit-Learn-Vorverarbeitungscontainer und ein Regressionsmodell bereitstellen, das auf dem integrierten linearen Lernalgorithmus](https://docs.aws.amazon.com/sagemaker/latest/dg/sklearn.html) basiert.](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) SageMaker Die Bereitstellung wird hinter einem einzigen Endpunkt in gehostet. SageMaker
**Anmerkung**
Die Bereitstellung in diesem Muster verwendet den Instance-Typ ml.m4.2xlarge. Wir empfehlen, einen Instance-Typ zu verwenden, der Ihren Anforderungen an die Datengröße und der Komplexität Ihres Workflows entspricht. Weitere Informationen finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/). Dieses Muster verwendet [vorgefertigte Docker-Images für Scikit-learn](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-docker-containers-scikit-learn-spark.html), aber Sie können Ihre eigenen Docker-Container verwenden und sie in Ihren Workflow integrieren.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
+ [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) und [Boto3-Bibliothek](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) [AWS Identity and Access Management (AWS IAM) mit SageMaker [Basisberechtigungen](https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html) und Amazon Simple Storage Service (Amazon S3) -Berechtigungen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-policy-language-overview.html)
**Produktversionen**
+ [Amazon SageMaker Python-SDK 2.49.2](https://sagemaker.readthedocs.io/en/v2.49.2/)
## Architektur
**Zieltechnologie-Stack**
+ Amazon Elastic Container Registry (Amazon ECR)
+ Amazon SageMaker
+ Amazon SageMaker Studio
+ Amazon Simple Storage Service (Amazon-S3)
+ [Echtzeit-Inferenzendpunkt](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) für Amazon SageMaker
**Zielarchitektur**
Das folgende Diagramm zeigt die Architektur für die Bereitstellung eines SageMaker Amazon-Pipeline-Modellobjekts.
![\[Architektur für die Bereitstellung eines SageMaker Pipeline-Modellobjekts\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/1105d51b-752f-46d7-962c-acef1fb3399f/images/12f06715-b1c2-4de0-b277-99ce87308152.png)
Das Diagramm zeigt den folgenden Workflow:
1. Ein SageMaker Notebook stellt ein Pipeline-Modell bereit.
1. Ein S3-Bucket speichert die Modellartefakte.
1. Amazon ECR ruft die Quellcontainer-Images aus dem S3-Bucket ab.
## Tools
**AWS-Tools**
+ [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist.
+ [Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) ist ein verwalteter ML-Service, der Ihnen hilft, ML-Modelle zu erstellen und zu trainieren und sie dann in einer produktionsbereiten gehosteten Umgebung bereitzustellen.
+ [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) ist eine webbasierte, integrierte Entwicklungsumgebung (IDE) für ML, mit der Sie Ihre ML-Modelle erstellen, trainieren, debuggen, bereitstellen und überwachen können.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
**Code**
Der Code für dieses Muster ist in der GitHub [Inference Pipeline with Scikit-Learn](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) und Linear Learner Repository verfügbar.
## Epen
### Bereiten Sie den Datensatz vor
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Bereiten Sie den Datensatz für Ihre Regressionsaufgabe vor. | [Öffnen Sie ein Notizbuch](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-open) in Amazon SageMaker Studio.Verwenden Sie den folgenden Beispielcode in Ihrem Notizbuch, um alle erforderlichen Bibliotheken zu importieren und Ihre Arbeitsumgebung zu initialisieren: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"
Um einen Beispieldatensatz herunterzuladen, fügen Sie Ihrem Notizbuch den folgenden Code hinzu:! mkdir abalone_data
! aws s3 cp s3://sagemaker-sample-files/datasets/tabular/uci_abalone/abalone.csv ./abalone_data
****Das Beispiel in diesem Muster verwendet den [Abalone-Datensatz](https://archive.ics.uci.edu/ml/datasets/abalone) aus dem UCI Machine Learning Repository. | Datenwissenschaftler |
| Laden Sie den Datensatz in einen S3-Bucket hoch. | Fügen Sie in dem Notizbuch, in dem Sie Ihren Datensatz zuvor vorbereitet haben, den folgenden Code hinzu, um Ihre Beispieldaten in einen S3-Bucket hochzuladen:WORK_DIRECTORY = "abalone_data"
train_input = sagemaker_session.upload_data(
path="{}/{}".format(WORK_DIRECTORY, "abalone.csv"),
bucket=bucket,
key_prefix="{}/{}".format(prefix, "train"),
)
| Datenwissenschaftler |
### Erstellen Sie den Datenpräprozessor mit SKLearn
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Bereiten Sie das Skript preprocessor.py vor. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-preprocessing-logic-into-an-ml-model-in-a-single-endpoint-using-an-inference-pipeline-in-amazon-sagemaker.html) | Datenwissenschaftler |
| Erstellen Sie das SKLearn Präprozessor-Objekt. | Um ein SKLearn Präprozessor-Objekt ( SKLearn Estimator genannt) zu erstellen, das Sie in Ihre endgültige Inferenz-Pipeline integrieren können, führen Sie den folgenden Code in Ihrem Notizbuch aus: 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})
| Datenwissenschaftler |
| Testen Sie die Inferenz des Präprozessors. | Um zu überprüfen, ob Ihr Präprozessor korrekt definiert ist, starten Sie einen [Batch-Transformationsauftrag](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html), indem Sie den folgenden Code in Ihr Notizbuch eingeben: SageMaker # 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
| |
### Erstellen Sie ein Modell für maschinelles Lernen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie ein Modellobjekt. | Um ein Modellobjekt zu erstellen, das auf dem linearen Lernalgorithmus basiert, geben Sie den folgenden Code in Ihr SageMaker Notizbuch ein: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)
Der obige Code ruft das entsprechende Amazon ECR Docker-Image aus der öffentlichen Amazon ECR Registry für das Modell ab, erstellt ein Schätzerobjekt und verwendet dieses Objekt dann, um das Regressionsmodell zu trainieren. | Datenwissenschaftler |
### Stellen Sie die endgültige Pipeline bereit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie das Pipeline-Modell bereit. | Um ein Pipeline-Modellobjekt (d. h. ein Präprozessor-Objekt) zu erstellen und das Objekt bereitzustellen, geben Sie den folgenden Code in Ihr SageMaker Notizbuch ein: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)
Sie können den im Modellobjekt verwendeten Instanztyp an Ihre Bedürfnisse anpassen. | Datenwissenschaftler |
| Testen Sie die Inferenz. | Um zu überprüfen, ob der Endpunkt ordnungsgemäß funktioniert, führen Sie den folgenden Beispiel-Inferenzcode in Ihrem SageMaker Notizbuch aus: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))
| Datenwissenschaftler |
## Zugehörige Ressourcen
+ [Vorverarbeitung von Eingabedaten vor dem Treffen von Prognosen mithilfe von SageMaker Amazon-Inferenz-Pipelines und Scikit-Learn (AWS Machine Learning Learning-Blog](https://aws.amazon.com/blogs/machine-learning/preprocess-input-data-before-making-predictions-using-amazon-sagemaker-inference-pipelines-and-scikit-learn/))
+ [Durchgängiges Machine Learning mit Amazon SageMaker](https://github.com/aws-samples/amazon-sagemaker-build-train-deploy) (GitHub)
# Stellen Sie mithilfe eines MCP-Servers mit Kiro und anderen Programmierassistenten eine Sicherheitsvalidierung in Echtzeit bereit.
*Ivan Girardi und Iker Reina Fuente, Amazon Web Services*
## Zusammenfassung
Dieses Muster beschreibt, wie ein Model Context Protocol (MCP) -Server implementiert wird, der drei branchenübliche Tools für Sicherheitsscans integriert, um eine umfassende Code-Sicherheitsanalyse zu ermöglichen. Der Server ermöglicht KI-Codierungsassistenten (wie Kiro, Amazon Q Developer und Cline), Codefragmente und Infrastructure-as-Code-Konfigurationen (IaC) automatisch zu scannen. Mit diesen Scans können die Codierungsassistenten dabei helfen, Sicherheitslücken, Fehlkonfigurationen und Compliance-Verstöße zu identifizieren.
KI-Codegeneratoren, die auf Millionen von Codefragmenten trainiert wurden, schaffen einen blinden Fleck in der Sicherheit — wie sicher waren diese Trainingsdaten? Dieses Muster ermöglicht eine Sicherheitsvalidierung in Echtzeit während der Codegenerierung und hilft Entwicklern, potenzielle Sicherheitsprobleme beim Programmieren zu erkennen und zu verstehen. Dieser Ansatz hilft Entwicklern dabei, sowohl direkte Sicherheitslücken als auch vererbte Risiken aufgrund von Abhängigkeiten zu beheben. Durch die Überbrückung der Lücke zwischen KI-Effizienz und Einhaltung von Sicherheitsvorschriften trägt dieses Muster dazu bei, die sichere Einführung von KI-gestützten Entwicklungstools zu ermöglichen.
Dieses Muster hilft Unternehmen dabei, ihre Sicherheitspraktiken bei der Entwicklung durch KI-gestützte Codierungstools zu verbessern und so kontinuierliche Sicherheitsüberprüfungen in mehreren Programmiersprachen und Infrastrukturdefinitionen bereitzustellen. Die Lösung kombiniert die Funktionen der folgenden Tools:
+ Checkov zum Scannen von IAC-Dateien, einschließlich Terraform- und Kubernetes-Manifestdateien AWS CloudFormation
+ Semgrep für die Analyse mehrerer Programmiersprachen wie Python JavaScript, Java und andere
+ Bandit für spezialisiertes Python-Sicherheitsscanning
Zu den wichtigsten Funktionen dieser Lösung gehören:
+ Delta-Scannen neuer Codesegmente, wodurch der Rechenaufwand reduziert wird
+ Isolierte Umgebungen mit Sicherheitstools, wodurch eine werkzeugübergreifende Kontamination verhindert wird
+ Nahtlose Integration mit KI-Codierungsassistenten (Kiro, Amazon Q Developer, Cline und andere)
+ Sicherheitsfeedback in Echtzeit während der Codegenerierung
+ Individuell anpassbare Scanregeln zur Einhaltung organisatorischer Vorschriften
Das Pattern bietet eine einheitliche Oberfläche für Sicherheitsscans mit standardisierten Antwortformaten und erleichtert so die Integration von Sicherheitsprüfungen in Entwicklungsabläufe. Das Muster verwendet Python und das MCP-Framework, um automatisiertes Sicherheitsfeedback zu liefern. Dieser Ansatz hilft Entwicklern dabei, Sicherheitsprobleme frühzeitig im Entwicklungsprozess zu erkennen und zu beheben und gleichzeitig anhand detaillierter Ergebnisse mehr über bewährte Sicherheitsverfahren zu erfahren.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver AWS-Konto Benutzer mit Zugriff auf Kiro oder Amazon Q Developer, wenn Sie einen dieser Codierungsassistenten verwenden möchten
+ [Python-Version 3.10 oder höher installiert](https://www.python.org/downloads/)
+ `uv`[Paketmanager installiert](https://docs.astral.sh/uv/getting-started/installation/)
+ Vertrautheit mit Tools und Konzepten für Sicherheitsscans
+ Grundlegendes Verständnis von IaC und Anwendungssicherheit
**Einschränkungen**
+ Das Scannen von Banditen ist nur auf Python-Dateien beschränkt.
+ Das Scannen in Echtzeit kann die Leistung großer Codebasen beeinträchtigen.
+ Toolspezifische Einschränkungen hängen von den unterstützten Dateiformaten und Sprachen ab.
+ Zur Validierung der Sicherheitsfeststellungen ist eine manuelle Überprüfung erforderlich.
+ Für die korrekte Interpretation der Ergebnisse von Sicherheitsscans ist Sicherheitsexpertise erforderlich.
+ Einige AWS-Services sind nicht in allen verfügbar AWS-Regionen. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie unter [AWS Dienste nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus.
**Produktversionen**
+ Python-Version 3.10 oder höher
+ Checkov Version 3.0.0 oder höher
+ Semgrep Version 1.45.0 oder höher
+ Bandit Version 1.7.5 oder höher
+ MCP [cli] Version 1.11.0 oder höher
+ Pydantic Version 1.10.0 oder höher
+ Loguru Version 0.6.0 oder höher
## Architektur
Das folgende Diagramm zeigt die Architektur für diese Lösung.
![\[KI-Assistenten senden Code an den MCP-Sicherheitsscanner-Server, um ihn an spezialisierte Scanner weiterzuleiten. Die Scanergebnisse werden an den Entwickler gesendet.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/fa623544-4d54-48af-a4e4-9b6a0624e776/images/9c881f95-76d0-40f6-983e-d987fd2097b8.png)
Das Diagramm zeigt den folgenden Workflow:
1. Der Entwickler verwendet KI-Assistenten (z. B. Kiro, Cline, Amazon Q Developer oder Roo Code), um Code zu generieren oder zu analysieren. Der KI-Assistent sendet den Code für den Sicherheitsscan.
1. Der MCP-Sicherheitsscanner-Server verarbeitet die Anfrage, indem er sie an den entsprechenden Spezialscanner weiterleitet: Checkov für IAC-Dateien, Semgrep für die Analyse mehrerer Programmiersprachen oder Bandit für Python-spezifische Sicherheitsscans.
1. Die Ergebnisse des Scanners mit Sicherheitsergebnissen, Schweregraden, detaillierten Beschreibungen und Lösungsvorschlägen werden über den KI-Assistenten an den Entwickler zurückgesendet.
1. Es wird eine kontinuierliche Feedback-Schleife eingerichtet, in der der Entwickler eine Sicherheitsvalidierung in Echtzeit erhält, was automatisierte Korrekturen durch KI-Assistenten ermöglicht und bewährte Sicherheitsverfahren während der Entwicklung fördert.
Die Architektur mindert die folgenden allgemeinen Sicherheitsrisiken:
+ Befehlsinjektion
+ Sofortige Injektion
+ Durchqueren von Pfaden
+ Angriffe auf Abhängigkeiten
+ Erschöpfung der Ressourcen
Die Architektur mindert diese häufigen Sicherheitsrisiken durch die Implementierung der folgenden bewährten Methoden:
+ Alle Benutzer- und KI-Modelleingaben werden in temporäre Dateien geschrieben.
+ Es werden keine direkten Eingaben für Befehle der Befehlszeilenschnittstelle (CLI) bereitgestellt.
+ Der Dateisystemzugriff ist nur auf temporäre Verzeichnisse und Dateien beschränkt.
+ Temporäre Dateien werden automatisch bereinigt.
+ Die Antworten auf das Scannen werden bereinigt.
+ Die Prozessisolierung, die die Prozessfähigkeiten einschränkt, wird durchgesetzt.
+ Alle Scanaktivitäten werden protokolliert.
**Automatisierung und Skalierung**
Das Muster unterstützt die Automatisierung durch die folgenden Funktionen:
+ Integration mit KI-Codierungsassistenten für automatisches Codescannen
+ Standardisierte API-Antworten für die automatisierte Verarbeitung
+ Konfiguration über MCP-Konfigurationsdateien
+ Support für die Stapelverarbeitung mehrerer Dateien
+ Skalierbares Scannen in mehreren Programmiersprachen und IaC-Formaten
Der Scanvorgang kann über die bereitgestellten API-Endpunkte automatisiert werden:
+ `scan_with_checkov`für IaC-Scannen
+ `scan_with_semgrep`für das Scannen von mehrsprachigem Code
+ `scan_with_bandit`für Python-spezifisches Scannen
+ `get_supported_formats`zur Formatvalidierung
Beachten Sie bei der Erweiterung der Scan-Tools die zuvor in diesem Abschnitt beschriebenen Entwurfsprinzipien und bewährten Methoden. Weitere Informationen finden Sie auch unter [Bewährte Methoden](#deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants-best-practices).
## Tools
**AWS-Services**
+ [Kiro](https://aws.amazon.com/documentation-overview/kiro/) ist ein agentischer Programmierdienst, der mit Entwicklern zusammenarbeitet, um Eingabeaufforderungen in detaillierte Spezifikationen und dann in funktionierenden Code, Dokumente und Tests umzuwandeln. Die Agenten von Kiro helfen Entwicklern dabei, schwierige Probleme zu lösen und Aufgaben wie die Generierung von Dokumentation und Komponententests zu automatisieren.
+ [Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) ist ein generativer KI-gestützter Konversationsassistent, der Ihnen helfen kann, Anwendungen zu verstehen, zu erstellen, zu erweitern und zu betreiben AWS .
**Andere Tools**
+ [Bandit](https://bandit.readthedocs.io/en/latest/) ist ein spezialisiertes Python-Sicherheitsscanner-Tool. Es erkennt häufig auftretende Python-Sicherheitsprobleme wie unsichere Funktionen, fest codierte Geheimnisse und Injection-Schwachstellen. Bandit bietet detaillierte Vertrauens- und Schweregradbewertungen.
+ [Checkov](https://github.com/bridgecrewio/checkov) ist ein statisches Codeanalyse-Tool, das IaC auf Sicherheits- und Compliance-Fehlkonfigurationen überprüft. Darüber hinaus erkennt Checkov Compliance-Verstöße und bewährte Sicherheitsverfahren.
+ [Cline](https://cline.bot/) ist ein KI-gestützter Codierungsassistent, der in VS Code läuft.
+ [Loguru](https://loguru.readthedocs.io/en/stable/) ist eine Datenvalidierungsbibliothek für Python.
+ [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) ist ein Open-Source-Framework für die Erstellung von KI-gestützten Entwicklungstools.
+ [Pydantic](https://docs.pydantic.dev/latest/) ist eine Datenvalidierungsbibliothek für Python.
+ [Semgrep](https://semgrep.dev/docs/introduction) analysiert den Quellcode auf Sicherheitslücken und Bugs. Es unterstützt mehrere Programmiersprachen. Semgrep verwendet sicherheitsorientierte Regelsätze für umfassende Analysen. Es bietet detaillierte Vertrauens- und Schweregradbewertungen.
**Code-Repository**
Der Code für dieses Muster ist im Repository GitHub [MCP Security Scanner: Real-Time Protection for AI Code Assistants](https://github.com/aws-samples/sample-mcp-security-scanner) verfügbar. Das Repository enthält die MCP-Serverimplementierung, Details zur MCP-Konfiguration für Kiro, Amazon Q Developer, Cline und andere, Konfigurationsbeispiele und Testdienstprogramme.
Die Repository-Struktur umfasst:
+ `security_scanner_mcp_server/`- Implementierung des Hauptservers
+ `docs/`- Dokumentation und Demomaterialien
+ `tests/`- Testdateien
+ `mcp-config-example.json`- Beispiel für eine MCP-Konfiguration
+ `requirements.txt`- Projektabhängigkeiten
## Best Practices
**Implementierung von Sicherheitsscans**
+ Überprüfen Sie die Sicherheitsergebnisse, um Probleme zu validieren und zu priorisieren.
+ Halten Sie die Scan-Tools (Checkov, Semgrep und Bandit) auf dem neuesten Stand.
+ Verwenden Sie das MCP-Sicherheitstool dieses Musters in Verbindung mit anderen Sicherheitsmaßnahmen und Tools.
+ Aktualisieren Sie regelmäßig Sicherheitsregelsätze und -richtlinien.
**Verwaltung der Konfiguration**
+ Verwenden Sie die MCP-Konfigurationsdateien in der offiziellen Versionskontrollquelle.
+ Dokumentieren Sie benutzerdefinierte Regeln und Konfigurationen.
**Integration**
+ Integrieren Sie Sicherheitsscans früh in den Entwicklungszyklus.
+ Richten Sie automatisiertes Scannen in Pre-Commit-Hooks oder in CI/CD-Pipelines (Continuous Integration and Continuous Deployment) ein.
+ Konfigurieren Sie geeignete Schweregradschwellenwerte für Ihre Umgebung.
+ Legen Sie klare Verfahren für den Umgang mit Sicherheitsergebnissen fest.
**Betriebliche Überlegungen**
+ Überwachen Sie die Scanleistung und den Ressourcenverbrauch.
+ Implementieren Sie die richtige Fehlerbehandlung und Protokollierung.
+ Pflegen Sie die Dokumentation der benutzerdefinierten Konfigurationen.
+ Richten Sie einen Prozess zur Überprüfung und Aktualisierung der Sicherheitsregeln ein.
Beachten Sie außerdem die folgenden bewährten Methoden:
+ Überprüfen Sie die Sicherheitsergebnisse immer in Ihrem spezifischen Kontext.
+ Halten Sie die Sicherheitstools und Abhängigkeiten auf dem neuesten Stand.
+ Verwenden Sie mehrere Sicherheitstools für eine umfassende Abdeckung.
+ Halten Sie sich in Ihrem Entwicklungsprozess an bewährte Sicherheitsmethoden.
## Epen
### (Kiro-Benutzer) Richten Sie den MCP-Sicherheitsscanner-Server ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konfigurieren Sie die MCP-Einstellungen. | Sie können die Konfigurationsdateien in Kiro entweder bearbeiten, indem Sie (Option 1) die Konfigurationsdateien manuell suchen oder (Option 2) die Kiro IDE verwenden.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/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": []
}
}
} | App-Developer |
### (Amazon Q Developer-Benutzer) Richten Sie den MCP-Sicherheitsscanner-Server ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konfigurieren Sie die MCP-Einstellungen. | Gehen Sie wie folgt vor, um die MCP-Einstellungen manuell zu konfigurieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/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"
}
}
}
} | App-Developer |
### (Cline-Benutzer) Richten Sie den MCP-Sicherheitsscanner-Server ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Konfigurieren Sie die MCP-Einstellungen. | Gehen Sie wie folgt vor, um die MCP-Einstellungen manuell zu konfigurieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/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": []
}
}
} | App-Developer |
### Beispiel für eine Codeanalyse mit Python und Bandit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie eine Codeanalyse durch. | Gehen Sie wie folgt vor, um eine Codeanalyse mit Python und Bandit durchzuführen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | App-Developer |
### Beispiel für eine Codeanalyse mit Terraform und Checkov
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie eine Codeanalyse durch. | Gehen Sie wie folgt vor, um eine Codeanalyse mithilfe von Terraform und Checkov durchzuführen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | App-Developer |
### Beispiel für erweiterte Scanfunktionen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie gezieltes Scannen durch. | Im Folgenden finden Sie Beispiele für Anfragen, mit denen Sie einen gezielten Scan durchführen können:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | App-Developer |
| Verwenden Sie Sicherheitsscans bei der Codegenerierung. | Gehen Sie wie folgt vor, um Sicherheitslücken mithilfe von Codegenerierungsschleifen zu beheben (in diesem Beispiel wird Kiro als Programmierassistent verwendet):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | App-Developer |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| Probleme bei der Einrichtung der Umgebung | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Probleme mit dem Scanner | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Probleme bei der Integration | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Zusätzlicher Support | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
## Zugehörige Ressourcen
**AWS Dokumentation**
+ [Infrastruktur als Code](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/infrastructure-as-code.html) (AWS Whitepaper *Einführung in DevOps on AWS*)
**Andere Ressourcen AWS **
+ [Bewährte Methoden für Sicherheit, Identität und Compliance](https://aws.amazon.com/architecture/security-identity-compliance/)
**Sonstige Ressourcen**
+ [Bandit-Dokumentation](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Checkov-Dokumentation](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Dokumentation zum Model Context Protocol (MCP)](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [OWASP Secure Coding Practices](https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/) (Website der OWASP Foundation)
+ [Semgrep-Dokumentation](https://aws.amazon.com/architecture/security-identity-compliance/)
## Zusätzliche Informationen
**Beispiel für eine MCP-Konfiguration mit aktivierter auto Genehmigung**
Ohne `autoApprove` Konfiguration muss der Benutzer die Genehmigung erteilen, den Code zum Scannen an den MCP-Sicherheitsserver zu senden. Wenn `autoApprove` konfiguriert, darf der Code-Assistent die Tools ohne Zustimmung des Benutzers aufrufen. Diese Tools werden lokal auf dem Computer ausgeführt, es werden keine Daten gesendet und es wird nur ein Codescan durchgeführt.
Die folgende Konfiguration ermöglicht die automatische Ausführung aller Sicherheitsscan-Funktionen:
```
{
"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"
]
}
}
}
```
Um die Debug-Protokollierung zu aktivieren, setzen Sie `"FASTMCP_LOG_LEVEL"` auf`"DEBUG"`.
**Dateiformate, die von Sicherheitsscan-Tools unterstützt werden**
Jedes Sicherheitsscan-Tool in dieser Lösung unterstützt die folgenden Dateiformate:
*Checkov (IaC)*
+ Terraform — .tf, .tfvars, .tfstate
+ CloudFormation — .yaml, .yml, .json, .template
+ Kubernetes — .yaml, .yml
+ Dockerfile — Docker-Datei
+ ARM — .json (Azure-Ressourcenmanager)
+ Bizeps — .Bizep
+ Serverlos — .yml, .yaml
+ Helm — .yaml, .yml, .tpl
+ GitHub Aktionen — .yml, .yaml
+ GitLab\$1ci — .yml, .yaml
+ Ansible — .yml, .yaml
*Semgrep (Quellcode)*
+ Python — .py
+ JavaScript — .js
+ TypeScript — .ts
+ Java — .java
+ Geh — .go
+ C — c..
+ C \$1\$1 — .cpp
+ C\$1 — .cs
+ Rubin — .rb
+ PHP — .php
+ Scala — .scala
+ Kotlin — .kt
+ Rost — .rs
*Bandit (nur Python)*
+ Python — .py
**Demos**
Probieren Sie zum Scannen von Code die folgenden Beispielanweisungen mit Ihrem KI-Assistenten aus:
+ „Scanne das aktuelle Skript und teile mir die Ergebnisse mit.“
+ „Scannen Sie die Zeilen 20—60 und teilen Sie mir die Ergebnisse mit.“
+ „Scannen Sie diese Amazon DynamoDB-Tabellenressource und teilen Sie mir das Ergebnis mit.“
Weitere Informationen finden Sie in dieser [Demo zum Scannen von Code](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_scan.gif) im Repository dieses Patterns GitHub .
Probieren Sie die folgenden Beispielaufforderungen aus, um sicheren Code zu generieren:
+ „Generieren Sie eine Terraform-Konfiguration, um eine DynamoDB-Tabelle mit aktivierter Verschlüsselung zu erstellen, und scannen Sie sie auf Sicherheitsprobleme.“
+ „Erstellen Sie eine Python-Lambda-Funktion, die in DynamoDB schreibt, und scannt sie auf Sicherheitslücken.“
+ „Generieren Sie eine CloudFormation Vorlage für einen S3-Bucket mit den richtigen Sicherheitseinstellungen und stellen Sie sicher, dass er die Sicherheitsüberprüfungen besteht.“
+ „Schreiben Sie ein Python-Skript, um DynamoDB mit Paginierung abzufragen und nach bewährten Sicherheitsmethoden zu suchen.“
+ „Erstellen Sie ein Kubernetes-Bereitstellungsmanifest für einen Microservice mit Sicherheitsverstärkung und validieren Sie es.“
Weitere Informationen finden Sie in dieser Demo zur [Codegenerierung mit Sicherheitsscanning](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_generation.gif) im Repository dieses Patterns. GitHub
# Entwickeln Sie mithilfe von RAG und Prompting fortschrittliche, auf KI basierende Chat-Assistenten ReAct
*Praveen Kumar Jeyarajan, Shuai Cao, Noah Hamilton, Kiowa Jackson, Jundong Qiao und Kara Yang, Amazon Web Services*
## Zusammenfassung
In einem typischen Unternehmen sind 70 Prozent seiner Daten in isolierten Systemen gespeichert. Mithilfe generativer, KI-gestützter Chat-Assistenten können Sie mithilfe von Interaktionen in natürlicher Sprache Einblicke und Beziehungen zwischen diesen Datensilos gewinnen. Um das Beste aus generativer KI herauszuholen, müssen die Ergebnisse vertrauenswürdig und genau sein und die verfügbaren Unternehmensdaten beinhalten. Erfolgreiche Chat-Assistenten hängen von folgenden Faktoren ab:
+ Generative KI-Modelle (wie Anthropic Claude 2)
+ Vektorisierung von Datenquellen
+ Fortgeschrittene Argumentationstechniken, wie z. B. das [ReAct Framework](https://www.promptingguide.ai/techniques/react), als Grundlage für das Modell
Dieses Muster bietet Datenabrufansätze aus Datenquellen wie Amazon Simple Storage Service (Amazon S3) -Buckets, AWS Glue und Amazon Relational Database Service (Amazon RDS). Aus diesen Daten wird Wert gewonnen, indem [Retrieval Augmented Generation (RAG](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)) mit Methoden verknüpft wird. chain-of-thought Die Ergebnisse unterstützen komplexe Chat-basierte Assistentengespräche, die sich auf die Gesamtheit der in Ihrem Unternehmen gespeicherten Daten stützen.
Dieses Muster verwendet SageMaker Amazon-Handbücher und Preisdatentabellen als Beispiel, um die Funktionen eines generativen KI-Assistenten auf Chatbasis zu untersuchen. Sie werden einen Chat-basierten Assistenten entwickeln, der Kunden hilft, den SageMaker Service zu bewerten, indem er Fragen zur Preisgestaltung und zu den Funktionen des Dienstes beantwortet. Die Lösung verwendet eine Streamlit-Bibliothek für die Erstellung der Frontend-Anwendung und das LangChain Framework für die Entwicklung des Anwendungs-Backends, das auf einem Large Language Model (LLM) basiert.
Anfragen an den Chat-Assistenten werden zunächst mit einer Absichtsklassifizierung beantwortet, sodass sie an einen von drei möglichen Workflows weitergeleitet werden. Der ausgefeilteste Arbeitsablauf kombiniert allgemeine Beratung mit komplexen Preisanalysen. Sie können das Muster an Anwendungsfälle in Unternehmen, Unternehmen und der Industrie anpassen.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ [AWS-Befehlszeilenschnittstelle (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installiert und konfiguriert
+ [AWS Cloud Development Kit (AWS CDK) Toolkit 2.114.1](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) oder höher installiert und konfiguriert
+ Grundkenntnisse in Python und AWS CDK
+ [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) installiert
+ [Docker installiert](https://docs.docker.com/get-docker/)
+ [Python 3.11 oder höher](https://www.python.org/downloads/) installiert und konfiguriert (weitere Informationen finden Sie im Abschnitt [Tools](#develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting-tools))
+ [Ein [aktives AWS-Konto](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-creating.html), das mithilfe von AWS CDK gestartet wurde](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)
+ Der [Zugriff auf die Modelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access) Amazon Titan und Anthropic Claude ist im Amazon Bedrock-Service aktiviert
+ [AWS-Sicherheitsanmeldedaten`AWS_ACCESS_KEY_ID`, einschließlich korrekt konfigurierter Anmeldeinformationen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html) in Ihrer Terminalumgebung
**Einschränkungen**
+ LangChain unterstützt nicht jedes LLM für Streaming. Die Modelle von Anthropic Claude werden unterstützt, Modelle von AI21 Labs jedoch nicht.
+ Diese Lösung wird auf einem einzigen AWS-Konto bereitgestellt.
+ Diese Lösung kann nur in AWS-Regionen eingesetzt werden, in denen Amazon Bedrock und Amazon Kendra verfügbar sind. Informationen zur Verfügbarkeit finden Sie in der Dokumentation für [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html#bedrock-regions) und [Amazon Kendra](https://docs.aws.amazon.com/general/latest/gr/kendra.html).
**Produktversionen**
+ Python-Version 3.11 oder höher
+ Streamlit Version 1.30.0 oder höher
+ Streamlit-Chat Version 0.1.1 oder höher
+ LangChain Version 0.1.12 oder höher
+ AWS CDK Version 2.132.1 oder höher
## Architektur
**Zieltechnologie-Stack**
+ Amazon Athena
+ Amazon Bedrock
+ Amazon Elastic Container Service (Amazon ECS)
+ AWS Glue
+ AWS Lambda
+ Amazon S3
+ Amazon Kendra
+ Elastic Load Balancing
**Zielarchitektur**
Der AWS-CDK-Code stellt alle Ressourcen bereit, die für die Einrichtung der Chat-basierten Assistentenanwendung in einem AWS-Konto erforderlich sind. Die in der folgenden Abbildung gezeigte Chat-basierte Assistentenanwendung wurde entwickelt, um verwandte Anfragen von Benutzern zu beantworten SageMaker . Benutzer stellen über einen Application Load Balancer eine Verbindung zu einer VPC her, die einen Amazon ECS-Cluster enthält, der die Streamlit-Anwendung hostet. Eine Orchestrierungs-Lambda-Funktion stellt eine Verbindung zur Anwendung her. S3-Bucket-Datenquellen stellen Daten für die Lambda-Funktion über Amazon Kendra und AWS Glue bereit. Die Lambda-Funktion stellt eine Verbindung zu Amazon Bedrock her, um Anfragen (Fragen) von Chat-basierten Assistentenbenutzern zu beantworten.
![\[Architekturdiagramm.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/4e5856cf-9489-41f8-a411-e3b8d8a50748.png)
1. Die Orchestrierungs-Lambda-Funktion sendet die LLM-Prompt-Anfrage an das Amazon Bedrock-Modell (Claude 2).
1. Amazon Bedrock sendet die LLM-Antwort zurück an die Orchestrierungs-Lambda-Funktion.
**Logikfluss innerhalb der Orchestrierungs-Lambda-Funktion**
Wenn Benutzer über die Streamlit-Anwendung eine Frage stellen, wird die Orchestrierungs-Lambda-Funktion direkt aufgerufen. Das folgende Diagramm zeigt den Logikfluss, wenn die Lambda-Funktion aufgerufen wird.
![\[Architekturdiagramm.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/70ae4736-06a6-4d3a-903a-edc5c10d78a0.png)
+ Schritt 1 — Die Eingabe `query` (Frage) wird in eine der drei Absichten eingeteilt:
+ Allgemeine SageMaker Orientierungsfragen
+ Allgemeine Fragen zur SageMaker Preisgestaltung (Schulung/Inferenz)
+ Komplexe Fragen im Zusammenhang mit und zur Preisgestaltung SageMaker
+ Schritt 2 — Die Eingabe `query` initiiert einen der drei Dienste:
+ `RAG Retrieval service`, das den relevanten Kontext aus der [Amazon Kendra Kendra-Vektordatenbank](https://aws.amazon.com/kendra/) abruft und das LLM über [Amazon Bedrock](https://aws.amazon.com/bedrock/) aufruft, um den abgerufenen Kontext als Antwort zusammenzufassen.
+ `Database Query service`, das das LLM, Datenbank-Metadaten und Beispielzeilen aus relevanten Tabellen verwendet, um die Eingabe in eine SQL-Abfrage umzuwandeln. `query` Der Datenbankabfragedienst führt die SQL-Abfrage für die SageMaker Preisdatenbank über [Amazon Athena](https://aws.amazon.com/athena/) aus und fasst die Abfrageergebnisse als Antwort zusammen.
+ `In-context ReACT Agent service`, der die Eingabe `query` in mehrere Schritte unterteilt, bevor eine Antwort bereitgestellt wird. Der Agent verwendet `RAG Retrieval service` und `Database Query service` als Hilfsmittel, um während des Argumentationsprozesses relevante Informationen abzurufen. Nachdem der Argumentations- und Handlungsprozess abgeschlossen ist, generiert der Agent die endgültige Antwort als Antwort.
+ Schritt 3 — Die Antwort der Orchestrierungs-Lambda-Funktion wird als Ausgabe an die Streamlit-Anwendung gesendet.
## Tools
**AWS-Services**
+ [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) ist ein interaktiver Abfrageservice, mit dem Sie Daten mithilfe von Standard-SQL direkt in Amazon Simple Storage Service (Amazon S3) analysieren können.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) ist ein vollständig verwalteter Service, der Ihnen leistungsstarke Basismodelle (FMs) von führenden KI-Startups und Amazon über eine einheitliche API zur Verfügung stellt.
+ Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) ist ein Softwareentwicklungs-Framework, das Sie bei der Definition und Bereitstellung der AWS-Cloud-Infrastruktur im Code unterstützt.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit AWS-Services interagieren können.
+ [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) ist ein hoch skalierbarer, schneller Container-Management-Service, der das Ausführen, Beenden und Verwalten von Containern in einem Cluster vereinfacht.
+ [AWS Glue](https://docs.aws.amazon.com/glue/) ist ein vollständig verwalteter Service zum Extrahieren, Transformieren und Laden (ETL). Er hilft Ihnen dabei, Daten zuverlässig zu kategorisieren, zu bereinigen, anzureichern und zwischen Datenspeichern und Datenströmen zu verschieben. Dieses Muster verwendet einen AWS Glue Glue-Crawler und eine AWS Glue Glue-Datenkatalogtabelle.
+ [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) ist ein intelligenter Suchdienst, der natürliche Sprachverarbeitung und fortschrittliche Algorithmen für maschinelles Lernen verwendet, um spezifische Antworten auf Suchfragen aus Ihren Daten zurückzugeben.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Er führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
+ [Elastic Load Balancing (ELB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) verteilt eingehenden Anwendungs- oder Netzwerkverkehr auf mehrere Ziele. Sie können beispielsweise den Datenverkehr auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances, Container und IP-Adressen in einer oder mehreren Availability Zones verteilen.
**Code-Repository**
Der Code für dieses Muster ist im GitHub [genai-bedrock-chatbot](https://github.com/awslabs/genai-bedrock-chatbot)Repository verfügbar.
Das Code-Repository enthält die folgenden Dateien und Ordner:
+ `assets`Ordner — Die statischen Objekte, das Architekturdiagramm und der öffentliche Datensatz
+ `code/lambda-container`folder — Der Python-Code, der in der Lambda-Funktion ausgeführt wird
+ `code/streamlit-app`folder — Der Python-Code, der als Container-Image in Amazon ECS ausgeführt wird
+ `tests`folder — Die Python-Dateien, die zum Komponententest der AWS-CDK-Konstrukte ausgeführt werden
+ `code/code_stack.py`— Das AWS-CDK-Konstrukt Python-Dateien, die zur Erstellung von AWS-Ressourcen verwendet werden
+ `app.py`— Die AWS-CDK-Stack-Python-Dateien, die zur Bereitstellung von AWS-Ressourcen im AWS-Zielkonto verwendet werden
+ `requirements.txt`— Die Liste aller Python-Abhängigkeiten, die für AWS CDK installiert werden müssen
+ `requirements-dev.txt`— Die Liste aller Python-Abhängigkeiten, die installiert werden müssen, damit AWS CDK die Unit-Test-Suite ausführen kann
+ `cdk.json`— Die Eingabedatei zur Bereitstellung von Werten, die zum Hochfahren von Ressourcen erforderlich sind
|
|
| Hinweis: Der AWS-CDK-Code verwendet [L3-Konstrukte (Layer 3)](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html) und [AWS Identity and Access Management (IAM) -Richtlinien, die von AWS für die Bereitstellung der Lösung verwaltet werden](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies). |
| --- |
## Best Practices
+ Das hier bereitgestellte Codebeispiel ist nur für eine proof-of-concept (PoC) oder Pilotdemo vorgesehen. Wenn Sie den Code in die Produktionsumgebung übernehmen möchten, sollten Sie die folgenden bewährten Methoden anwenden:
+ Die [Amazon S3 S3-Zugriffsprotokollierung ist aktiviert](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html).
+ [VPC Flow Logs ist aktiviert](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html).
+ Der [Amazon Kendra Enterprise Edition-Index](https://docs.aws.amazon.com/whitepapers/latest/how-aws-pricing-works/amazon-kendra.html) ist aktiviert.
+ Richten Sie die Überwachung und Warnung für die Lambda-Funktion ein. Weitere Informationen finden Sie unter [Überwachung und Problembehandlung von Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Allgemeine bewährte Methoden für die Arbeit mit Lambda-Funktionen finden Sie in der [AWS-Dokumentation](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Epen
### AWS-Anmeldeinformationen auf Ihrem lokalen Computer einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Exportieren Sie Variablen für das Konto und die AWS-Region, in der der Stack bereitgestellt wird. | Führen Sie die folgenden Befehle aus, um AWS-Anmeldeinformationen für AWS CDK mithilfe von Umgebungsvariablen bereitzustellen.export CDK_DEFAULT_ACCOUNT=<12 Digit AWS Account Number>
export CDK_DEFAULT_REGION=
| DevOps Ingenieur, AWS DevOps |
| Richten Sie das AWS-CLI-Profil ein. | Folgen Sie den Anweisungen in der [AWS-Dokumentation, um das AWS-CLI-Profil](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/keys-profiles-credentials.html) für das Konto einzurichten. | DevOps Ingenieur, AWS DevOps |
### So richten Sie Ihre Umgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das Repo auf Ihrem lokalen Computer. | Um das Repository zu klonen, führen Sie den folgenden Befehl in Ihrem Terminal aus.git clone https://github.com/awslabs/genai-bedrock-chatbot.git
| DevOps Ingenieur, AWS DevOps |
| Richten Sie die virtuelle Python-Umgebung ein und installieren Sie die erforderlichen Abhängigkeiten. | Führen Sie die folgenden Befehle aus, um die virtuelle Python-Umgebung einzurichten.cd genai-bedrock-chatbot
python3 -m venv .venv
source .venv/bin/activate
Führen Sie den folgenden Befehl aus, um die erforderlichen Abhängigkeiten einzurichten.pip3 install -r requirements.txt
| DevOps Ingenieur, AWS DevOps |
| Richten Sie die AWS-CDK-Umgebung ein und synthetisieren Sie den AWS-CDK-Code. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps Ingenieur, AWS DevOps |
### Konfigurieren und implementieren Sie die Chat-basierte Assistentenanwendung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Gewähren Sie Zugriff auf das Claude-Modell. | Folgen Sie den Anweisungen in der [Amazon Bedrock-Dokumentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access), um den Zugriff auf das Anthropic-Claude-Modell für Ihr AWS-Konto zu aktivieren. | AWS DevOps |
| Stellen Sie Ressourcen im Konto bereit. | Gehen Sie wie folgt vor, um Ressourcen im AWS-Konto mithilfe des AWS-CDK bereitzustellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)Nach erfolgreicher Bereitstellung können Sie über die im Abschnitt CloudFormation **Ausgaben** angegebene URL auf die Chat-basierte Assistentenanwendung zugreifen. | AWS DevOps, DevOps Ingenieur |
| Führen Sie den AWS Glue Glue-Crawler aus und erstellen Sie die Datenkatalogtabelle. | Ein [AWS Glue Glue-Crawler](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) wird verwendet, um das Datenschema dynamisch zu halten. Die Lösung erstellt und aktualisiert Partitionen in der [AWS Glue Data Catalog-Tabelle](https://docs.aws.amazon.com/athena/latest/ug/querying-glue-catalog.html), indem sie den Crawler bei Bedarf ausführt. Nachdem die CSV-Datensatzdateien in den S3-Bucket kopiert wurden, führen Sie den AWS Glue Glue-Crawler aus und erstellen Sie das Datenkatalog-Tabellenschema zum Testen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)Der AWS-CDK-Code konfiguriert den AWS Glue-Crawler so, dass er bei Bedarf ausgeführt wird. Sie können ihn aber auch so [planen](https://docs.aws.amazon.com/glue/latest/dg/schedule-crawler.html), dass er regelmäßig ausgeführt wird. | DevOps Ingenieur, AWS DevOps |
| Initiieren Sie die Indizierung von Dokumenten. | Nachdem die Dateien in den S3-Bucket kopiert wurden, verwenden Sie Amazon Kendra, um sie zu crawlen und zu indizieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)[Der AWS-CDK-Code konfiguriert die Amazon Kendra-Indexsynchronisierung so, dass sie bei Bedarf ausgeführt wird. Sie können sie jedoch auch regelmäßig ausführen, indem Sie den Parameter Schedule verwenden.](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html#cron) | AWS DevOps, DevOps Ingenieur |
### Bereinigen Sie alle AWS-Ressourcen in der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Entfernen Sie die AWS-Ressourcen. | Nachdem Sie die Lösung getestet haben, bereinigen Sie die Ressourcen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps Ingenieur, AWS DevOps |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| AWS CDK gibt Fehler zurück. | Hilfe bei Problemen mit AWS CDK finden Sie unter [Behebung häufiger Probleme mit AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html). |
## Zugehörige Ressourcen
+ Amazonas-Grundgestein:
+ [Modellzugriff](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Inferenzparameter für Fundamentmodelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Lambda-Funktionen mit Python erstellen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Erste Schritte mit dem AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Arbeiten mit dem AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Generativer KI-Anwendungsgenerator auf AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
+ [LangChain Dokumentation](https://python.langchain.com/docs/get_started/introduction)
+ [Rationalisierte Dokumentation](https://docs.streamlit.io/)
## Zusätzliche Informationen
**AWS CDK-Befehle**
Beachten Sie bei der Arbeit mit AWS CDK die folgenden nützlichen Befehle:
+ Listet alle Stacks in der App auf
```
cdk ls
```
+ Gibt die synthetisierte AWS-Vorlage aus CloudFormation
```
cdk synth
```
+ Stellt den Stack für Ihr AWS-Standardkonto und Ihre Region bereit
```
cdk deploy
```
+ Vergleicht den bereitgestellten Stack mit dem aktuellen Status
```
cdk diff
```
+ Öffnet die AWS CDK-Dokumentation
```
cdk docs
```
+ Löscht den CloudFormation Stack und entfernt von AWS bereitgestellte Ressourcen
```
cdk destroy
```
# Entwickeln Sie mithilfe von Amazon Bedrock-Agenten und Wissensdatenbanken einen vollautomatischen Chat-basierten Assistenten
*Jundong Qiao, Shuai Cao, Noah Hamilton, Kiowa Jackson, Praveen Kumar Jeyarajan und Kara Yang, Amazon Web Services*
## Zusammenfassung
Viele Unternehmen stehen vor Herausforderungen, wenn es darum geht, einen chatbasierten Assistenten zu entwickeln, der in der Lage ist, verschiedene Datenquellen zu orchestrieren, um umfassende Antworten zu bieten. Dieses Muster bietet eine Lösung für die Entwicklung eines Chat-basierten Assistenten, der Anfragen sowohl aus der Dokumentation als auch aus Datenbanken beantworten kann, und das bei einer einfachen Bereitstellung.
Beginnend mit [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) bietet dieser vollständig verwaltete Service für generative künstliche Intelligenz (KI) eine breite Palette fortschrittlicher Basismodelle (FMs). Dies erleichtert die effiziente Erstellung generativer KI-Anwendungen mit einem starken Fokus auf Datenschutz und Sicherheit. Im Zusammenhang mit dem Abruf von Dokumenten ist die [Retrieval Augmented Generation (RAG)](https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-customize-rag.html) ein zentrales Merkmal. Es verwendet [Wissensdatenbanken](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html), um FM-Eingabeaufforderungen um kontextrelevante Informationen aus externen Quellen zu erweitern. Ein [Amazon OpenSearch Serverless-Index](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) dient als Vektordatenbank hinter den Wissensdatenbanken für Amazon Bedrock. Diese Integration wird durch sorgfältiges, zeitnahes Engineering verbessert, um Ungenauigkeiten zu minimieren und sicherzustellen, dass die Antworten in einer sachlichen Dokumentation verankert sind. Für Datenbankabfragen transformieren Amazon Bedrock Textanfragen in strukturierte SQL-Abfragen, die spezifische Parameter enthalten. FMs [Dies ermöglicht den präzisen Abruf von Daten aus Datenbanken, die von Datenbanken verwaltet werden.AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/define-database.html) [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) wird für diese Abfragen verwendet.
Um kompliziertere Anfragen zu bearbeiten und umfassende Antworten zu erhalten, sind Informationen erforderlich, die sowohl aus der Dokumentation als auch aus Datenbanken stammen. [Agents for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) ist eine generative KI-Funktion, mit der Sie autonome Agenten erstellen können, die komplexe Aufgaben verstehen und sie für die Orchestrierung in einfachere Aufgaben aufteilen können. Die Kombination der Erkenntnisse aus den vereinfachten Aufgaben, die durch die autonomen Agenten von Amazon Bedrock unterstützt werden, verbessert die Informationssynthese und führt zu gründlicheren und umfassenderen Antworten. Dieses Muster zeigt, wie Sie mithilfe von Amazon Bedrock und den zugehörigen generativen KI-Diensten und -Funktionen innerhalb einer automatisierten Lösung einen chatbasierten Assistenten erstellen können.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver AWS-Konto
+ [Docker, installiert](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK), [installiert](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) und per [Bootstrapping auf oder](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) `us-east-1` `us-west-2` AWS-Regionen
+ AWS CDK [Toolkit-Version 2.114.1 oder höher, installiert](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ AWS Command Line Interface [https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Python Version 3.11 oder höher, installiert](https://www.python.org/downloads/)
+ [Aktivieren Sie in Amazon Bedrock den Zugriff auf](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html) Claude 2, Claude 2.1, Claude Instant und Titan Embeddings G1 — Text
**Einschränkungen**
+ Diese Lösung wird in einer einzigen Lösung bereitgestellt. AWS-Konto
+ Diese Lösung kann nur dort eingesetzt werden AWS-Regionen , wo Amazon Bedrock und Amazon OpenSearch Serverless unterstützt werden. Weitere Informationen finden Sie in der Dokumentation für [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) und [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html#serverless-regions).
**Produktversionen**
+ LLAMA-Index Version 0.10.6 oder höher
+ Sqlalchemy Version 2.0.23 oder höher
+ OpenSearch-PY Version 2.4.2 oder höher
+ Requests\$1AWS4Auth Version 1.2.3 oder höher
+ AWS SDK für Python (Boto3) Version 1.34.57 oder höher
## Architektur
**Zieltechnologie-Stack**
Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)ist ein Open-Source-Framework für die Softwareentwicklung, mit dem Cloud-Infrastruktur im Code definiert und bereitgestellt werden kann. AWS CloudFormation Der in diesem Muster verwendete AWS CDK Stack stellt die folgenden AWS Ressourcen bereit:
+ AWS Key Management Service (AWS KMS)
+ Amazon Simple Storage Service (Amazon-S3)
+ AWS Glue Data Catalog, für die AWS Glue Datenbankkomponente
+ AWS Lambda
+ AWS Identity and Access Management (ICH BIN)
+ Amazon OpenSearch Serverlos
+ 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)
**Zielarchitektur**
![\[Architekturdiagramm mit einer Amazon Bedrock-Wissensdatenbank und einem Agenten\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/15372718-3a5d-4918-9cfa-422c455f288d/images/ff19152e-0bb6-4758-a6dd-4f6140e55113.png)
Das Diagramm zeigt ein umfassendes AWS cloudnatives Setup in einem einzigen System AWS-Region, wobei mehrere verwendet werden. AWS-Services Die primäre Schnittstelle für den Chat-basierten Assistenten ist eine [Streamlit-Anwendung](https://docs.streamlit.io/), die auf einem Amazon ECS-Cluster gehostet wird. Ein [Application Load Balancer](https://aws.amazon.com/elasticloadbalancing/application-load-balancer/) verwaltet die Barrierefreiheit. Über diese Schnittstelle gestellte Abfragen aktivieren die `Invocation` Lambda-Funktion, die dann eine Schnittstelle zu Agenten für Amazon Bedrock herstellt. Dieser Agent beantwortet Benutzeranfragen, indem er entweder die Wissensdatenbanken für Amazon Bedrock konsultiert oder eine `Agent executor` Lambda-Funktion aufruft. Diese Funktion löst nach einem vordefinierten API-Schema eine Reihe von Aktionen aus, die dem Agenten zugeordnet sind. Die Wissensdatenbanken für Amazon Bedrock verwenden einen OpenSearch serverlosen Index als Grundlage für ihre Vektordatenbank. Darüber hinaus generiert die `Agent executor` Funktion SQL-Abfragen, die über Amazon Athena für die AWS Glue Datenbank ausgeführt werden.
## Tools
**AWS-Services**
+ [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) ist ein interaktiver Abfrageservice, mit dem Sie Daten mithilfe von Standard-SQL direkt in Amazon Simple Storage Service (Amazon S3) analysieren können.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) ist ein vollständig verwalteter Service, der Ihnen leistungsstarke Basismodelle (FMs) von führenden KI-Startups und Amazon über eine einheitliche API zur Verfügung stellt.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)ist ein Softwareentwicklungs-Framework, das Ihnen hilft, AWS Cloud-Infrastruktur im Code zu definieren und bereitzustellen.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können.
+ [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) ist ein hoch skalierbarer, schneller Container-Management-Service, der das Ausführen, Beenden und Verwalten von Containern in einem Cluster vereinfacht.
+ [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) verteilt den eingehenden Anwendungs- oder Netzwerkverkehr auf mehrere Ziele. Sie können beispielsweise den Datenverkehr auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances, Container und IP-Adressen in einer oder mehreren Availability Zones verteilen.
+ [AWS Glue](https://docs.aws.amazon.com/glue/)ist ein vollständig verwalteter ETL-Service (Extrahieren, Transformieren und Laden). Er hilft Ihnen dabei, Daten zuverlässig zu kategorisieren, zu bereinigen, anzureichern und zwischen Datenspeichern und Datenströmen zu verschieben. Dieses Muster verwendet einen AWS Glue Crawler und eine AWS Glue Data Catalog Tabelle.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne dass Sie Server bereitstellen oder verwalten müssen. Es führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) ist eine serverlose On-Demand-Konfiguration für Amazon OpenSearch Service. In diesem Muster dient ein OpenSearch serverloser Index als Vektordatenbank für die Wissensdatenbanken für Amazon Bedrock.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
**Andere Tools**
+ [Streamlit](https://docs.streamlit.io/) ist ein Open-Source-Python-Framework zur Erstellung von Datenanwendungen.
**Code-Repository**
Der Code für dieses Muster ist im GitHub [genai-bedrock-agent-chatbot](https://github.com/awslabs/genai-bedrock-agent-chatbot/)Repository verfügbar. Das Code-Repository enthält die folgenden Dateien und Ordner:
+ `assets`Ordner — Die statischen Elemente, wie das Architekturdiagramm und der öffentliche Datensatz.
+ `code/lambdas/action-lambda`folder — Der Python-Code für die Lambda-Funktion, die als Aktion für den Amazon Bedrock-Agenten fungiert.
+ `code/lambdas/create-index-lambda`folder — Der Python-Code für die Lambda-Funktion, die den OpenSearch Serverless-Index erstellt.
+ `code/lambdas/invoke-lambda`folder — Der Python-Code für die Lambda-Funktion, die den Amazon Bedrock-Agenten aufruft, der direkt aus der Streamlit-Anwendung aufgerufen wird.
+ `code/lambdas/update-lambda`folder — Der Python-Code für die Lambda-Funktion, die Ressourcen aktualisiert oder löscht, nachdem die AWS Ressourcen über die bereitgestellt wurden. AWS CDK
+ `code/layers/boto3_layer`folder — Der AWS CDK Stapel, der eine Boto3-Ebene erstellt, die von allen Lambda-Funktionen gemeinsam genutzt wird.
+ `code/layers/opensearch_layer`Ordner — Der AWS CDK Stack, der eine OpenSearch serverlose Schicht erstellt, die alle Abhängigkeiten installiert, um den Index zu erstellen.
+ `code/streamlit-app`folder — Der Python-Code, der als Container-Image in Amazon ECS ausgeführt wird.
+ `code/code_stack.py`— Das AWS CDK Konstrukt Python-Dateien, die AWS Ressourcen erstellen.
+ `app.py`— Die AWS CDK Stapel-Python-Dateien, die AWS Ressourcen im AWS Zielkonto bereitstellen.
+ `requirements.txt`— Die Liste aller Python-Abhängigkeiten, die für die installiert werden müssen AWS CDK.
+ `cdk.json`— Die Eingabedatei zur Bereitstellung der Werte, die zum Erstellen von Ressourcen erforderlich sind. Außerdem können Sie die Lösung in den `context/config` Feldern entsprechend anpassen. Weitere Informationen zur Anpassung finden Sie im Abschnitt [Zusätzliche Informationen](#develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases-additional).
## Best Practices
+ Das hier bereitgestellte Codebeispiel dient nur proof-of-concept (PoC) oder Pilotzwecken. Wenn Sie den Code für die Produktion verwenden möchten, sollten Sie unbedingt die folgenden bewährten Methoden anwenden:
+ [Amazon S3 S3-Zugriffsprotokollierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html) aktivieren
+ [VPC-Flow-Logs](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) aktivieren
+ Richten Sie die Überwachung und Warnung für die Lambda-Funktionen ein. Weitere Informationen finden Sie unter [Überwachung und Problembehandlung von Lambda-Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Bewährte Methoden finden Sie unter [Bewährte Methoden für die Arbeit mit AWS Lambda Funktionen](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Epen
### Richten Sie AWS Anmeldeinformationen auf Ihrer lokalen Workstation ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Exportieren Sie Variablen für das Konto und die Region. | Führen Sie die folgenden Befehle aus, um mithilfe AWS CDK von Umgebungsvariablen AWS Anmeldeinformationen für bereitzustellen.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps Ingenieur |
| Richten Sie das AWS CLI benannte Profil ein. | Folgen Sie den Anweisungen unter [Konfiguration und Einstellungen der Anmeldeinformationsdatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html), um das AWS CLI benannte Profil für das Konto einzurichten. | AWS DevOps, DevOps Ingenieur |
### So richten Sie Ihre Umgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das Repo auf Ihre lokale Workstation. | Um das Repository zu klonen, führen Sie den folgenden Befehl in Ihrem Terminal aus.git clone https://github.com/awslabs/genai-bedrock-agent-chatbot.git
| DevOps Ingenieur, AWS DevOps |
| Richten Sie die virtuelle Python-Umgebung ein. | Führen Sie die folgenden Befehle aus, um die virtuelle Python-Umgebung einzurichten.cd genai-bedrock-agent-chatbot
python3 -m venv .venv
source .venv/bin/activate
Führen Sie den folgenden Befehl aus, um die erforderlichen Abhängigkeiten einzurichten.pip3 install -r requirements.txt
| DevOps Ingenieur, AWS DevOps |
| Richten Sie die AWS CDK Umgebung ein. | Führen Sie den Befehl aus, um den Code in eine AWS CloudFormation Vorlage zu konvertieren`cdk synth`. | AWS DevOps, DevOps Ingenieur |
### Konfiguration und Bereitstellung der Anwendung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie Ressourcen im Konto bereit. | Gehen Sie wie folgt vor AWS CDK, um Ressourcen im mithilfe AWS-Konto von bereitzustellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases.html)Nach erfolgreicher Bereitstellung können Sie über die URL auf der Registerkarte **Outputs** in der Konsole auf die Chat-basierte Assistentenanwendung zugreifen. CloudFormation | DevOps Ingenieur, AWS DevOps |
### Bereinigen Sie alle AWS Ressourcen in der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Entfernen Sie die AWS Ressourcen. | Nachdem Sie die Lösung getestet haben, führen Sie den Befehl aus, um die Ressourcen zu bereinigen`cdk destroy`. | AWS DevOps, DevOps Ingenieur |
## Zugehörige Ressourcen
**AWS Dokumentation**
+ Ressourcen von Amazon Bedrock:
+ [Modellzugriff](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Inferenzparameter für Fundamentmodelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Agenten für Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html)
+ [Wissensdatenbanken für Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)
+ [Lambda-Funktionen mit Python erstellen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ AWS CDK Ressourcen:
+ [Fangen Sie an mit dem AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Behebung häufig auftretender AWS CDK Probleme](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Arbeiten mit dem AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Generativer KI-Anwendungsgenerator aktiviert AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Andere AWS Ressourcen**
+ [Vector Engine für Amazon OpenSearch Serverless](https://aws.amazon.com/opensearch-service/serverless-vector-engine/)
**Sonstige Ressourcen**
+ [LlamaIndex Dokumentation](https://docs.llamaindex.ai/en/stable/)
+ [Rationalisierte Dokumentation](https://docs.streamlit.io/)
## Zusätzliche Informationen
**Passen Sie den Chat-basierten Assistenten mit Ihren eigenen Daten an**
Folgen Sie diesen strukturierten Richtlinien, um Ihre benutzerdefinierten Daten für die Bereitstellung der Lösung zu integrieren. Diese Schritte sollen einen nahtlosen und effizienten Integrationsprozess gewährleisten, sodass Sie die Lösung effektiv mit Ihren maßgeschneiderten Daten implementieren können.
*Für die Datenintegration in der Wissensdatenbank*
**Datenaufbereitung**
1. Suchen Sie das `assets/knowledgebase_data_source/` Verzeichnis.
1. Platzieren Sie Ihren Datensatz in diesem Ordner.
**Anpassungen der Konfiguration**
1. Öffnen Sie die `cdk.json` Datei.
1. Navigieren Sie zu dem `context/configure/paths/knowledgebase_file_name` Feld und aktualisieren Sie es dann entsprechend.
1. Navigieren Sie zu dem `bedrock_instructions/knowledgebase_instruction` Feld, und aktualisieren Sie es dann, damit es die Nuancen und den Kontext Ihres neuen Datensatzes genau wiedergibt.
*Für die Integration von Strukturdaten*
**Organisation der Daten**
1. Erstellen Sie innerhalb des `assets/data_query_data_source/` Verzeichnisses ein Unterverzeichnis, z. B. `tabular_data`
1. Platzieren Sie Ihren strukturierten Datensatz (akzeptable Formate umfassen CSV, JSON, ORC und Parquet) in diesem neu erstellten Unterordner.
1. Wenn Sie eine Verbindung zu einer vorhandenen Datenbank herstellen, aktualisieren Sie die Funktion `create_sql_engine()` unter So stellen Sie eine Verbindung `code/lambda/action-lambda/build_query_engine.py` zu Ihrer Datenbank her.
**Konfiguration und Code-Updates**
1. Aktualisieren Sie das `context/configure/paths/athena_table_data_prefix` Feld in der `cdk.json` Datei so, dass es dem neuen Datenpfad entspricht.
1. Überarbeiten Sie, `code/lambda/action-lambda/dynamic_examples.csv` indem Sie neue text-to-SQL Beispiele einbeziehen, die Ihrem Datensatz entsprechen.
1. Überarbeiten Sie`code/lambda/action-lambda/prompt_templates.py`, um die Attribute Ihres strukturierten Datensatzes widerzuspiegeln.
1. Aktualisieren Sie das `context/configure/bedrock_instructions/action_group_description` Feld in der `cdk.json` Datei, um den Zweck und die Funktionalität der `Action group` Lambda-Funktion zu erläutern.
1. Erläutern Sie in der `assets/agent_api_schema/artifacts_schema.json` Datei die neuen Funktionen Ihrer `Action group` Lambda-Funktion.
*Allgemeines Update*
Geben Sie in der `cdk.json` Datei im `context/configure/bedrock_instructions/agent_instruction` Abschnitt eine umfassende Beschreibung der beabsichtigten Funktionalität und des Entwurfszwecks des Amazon Bedrock-Agenten unter Berücksichtigung der neu integrierten Daten.
# Dokumentieren Sie institutionelles Wissen anhand von Spracheingaben mithilfe von Amazon Bedrock und Amazon Transcribe
*Praveen Kumar Jeyarajan, Jundong Qiao, Rajiv Upadhyay und Megan Wu, Amazon Web Services*
## Zusammenfassung
Die Erfassung von institutionellem Wissen ist für den Erfolg und die Widerstandsfähigkeit von Organisationen von größter Bedeutung. Institutionelles Wissen steht für das kollektive Wissen, die Erkenntnisse und die Erfahrungen, die Mitarbeiter im Laufe der Zeit gesammelt haben. Diese sind oft stillschweigend und werden informell weitergegeben. Diese Fülle an Informationen umfasst einzigartige Ansätze, bewährte Verfahren und Lösungen für komplizierte Probleme, die möglicherweise an anderer Stelle nicht dokumentiert sind. Durch die Formalisierung und Dokumentation dieses Wissens können Unternehmen das institutionelle Gedächtnis bewahren, Innovationen fördern, Entscheidungsprozesse verbessern und die Lernkurven neuer Mitarbeiter beschleunigen. Darüber hinaus fördert es die Zusammenarbeit, befähigt Einzelpersonen und fördert eine Kultur der kontinuierlichen Verbesserung. Letztlich hilft die Nutzung von institutionellem Wissen Unternehmen dabei, ihr wertvollstes Kapital — die kollektive Intelligenz ihrer Belegschaft — zu nutzen, um Herausforderungen zu bewältigen, Wachstum voranzutreiben und Wettbewerbsvorteile in dynamischen Geschäftsumgebungen zu wahren.
Dieses Muster erklärt, wie institutionelles Wissen mithilfe von Sprachaufzeichnungen von leitenden Mitarbeitern erfasst werden kann. Es verwendet [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) und [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) für die systematische Dokumentation und Überprüfung. Indem Sie dieses informelle Wissen dokumentieren, können Sie es bewahren und an nachfolgende Mitarbeiterkohorten weitergeben. Dieses Bestreben unterstützt betriebliche Exzellenz und verbessert die Effektivität von Schulungsprogrammen durch die Einbeziehung von praktischem Wissen, das durch direkte Erfahrung erworben wurde.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto
+ [Docker, installiert](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK) Version 2.114.1 oder höher, [installiert](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) und in die oder [AWS-Regionen gestartet](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) `us-east-1` `us-west-2`
+ [AWS CDK Toolkit Version 2.114.1 oder höher, installiert](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ AWS-Befehlszeilenschnittstelle (AWS CLI), [installiert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und [konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ [Python Version 3.12 oder höher, installiert](https://www.python.org/downloads/)
+ Berechtigungen zum Erstellen von Ressourcen für Amazon Transcribe, Amazon Bedrock, Amazon Simple Storage Service (Amazon S3) und AWS Lambda
**Einschränkungen**
+ Diese Lösung wird auf einem einzigen AWS-Konto bereitgestellt.
+ Diese Lösung kann nur in AWS-Regionen eingesetzt werden, in denen Amazon Bedrock und Amazon Transcribe verfügbar sind. Informationen zur Verfügbarkeit finden Sie in der Dokumentation für [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) und [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html#tsc-regions).
+ Die Audiodateien müssen in einem Format vorliegen, das Amazon Transcribe unterstützt. Eine Liste der unterstützten Formate finden Sie unter [Medienformate](https://docs.aws.amazon.com/transcribe/latest/dg/how-input.html#how-input-audio) in der Transcribe-Dokumentation.
**Produktversionen**
+ AWS-SDK SDK for Python (Boto3) Version 1.34.57 oder höher
+ LangChain Version 0.1.12 oder höher
## Architektur
Die Architektur stellt einen serverlosen Workflow auf AWS dar. [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) orchestriert Lambda-Funktionen für die Audioverarbeitung, Textanalyse und Dokumentgenerierung. Das folgende Diagramm zeigt den Step Functions Functions-Workflow, der auch als *Zustandsmaschine* bezeichnet wird.
![\[Architekturdiagramm der Step Functions Functions-Zustandsmaschine, die ein Dokument generiert\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/f1e0106d-b046-4adc-9718-c299efb7b436/images/e90298ca-1b7f-4c3e-97bd-311a9d5a4997.png)
Jeder Schritt in der Zustandsmaschine wird von einer eigenen Lambda-Funktion behandelt. Im Folgenden sind die Schritte im Prozess der Dokumentgenerierung aufgeführt:
1. Die `preprocess` Lambda-Funktion validiert die an Step Functions übergebenen Eingaben und listet alle Audiodateien auf, die im angegebenen Amazon S3 S3-URI-Ordnerpfad vorhanden sind. Downstream-Lambda-Funktionen im Workflow verwenden die Dateiliste, um das Dokument zu validieren, zusammenzufassen und zu generieren.
1. Die `transcribe` Lambda-Funktion verwendet Amazon Transcribe, um Audiodateien in Texttranskripte umzuwandeln. Diese Lambda-Funktion ist dafür verantwortlich, den Transkriptionsprozess einzuleiten und Sprache präzise in Text umzuwandeln, der dann für die nachfolgende Verarbeitung gespeichert wird.
1. Die `validate` Lambda-Funktion analysiert die Texttranskripte und bestimmt die Relevanz der Antworten auf die ersten Fragen. Durch die Verwendung eines großen Sprachmodells (LLM) über Amazon Bedrock werden themenbezogene Antworten identifiziert und von themenfremden Antworten getrennt.
1. Die `summarize` Lambda-Funktion verwendet Amazon Bedrock, um eine kohärente und präzise Zusammenfassung der themenbezogenen Antworten zu erstellen.
1. Die `generate` Lambda-Funktion fasst die Zusammenfassungen zu einem gut strukturierten Dokument zusammen. Es kann das Dokument gemäß vordefinierten Vorlagen formatieren und alle zusätzlichen erforderlichen Inhalte oder Daten enthalten.
1. Wenn eine der Lambda-Funktionen ausfällt, erhalten Sie eine E-Mail-Benachrichtigung über Amazon Simple Notification Service (Amazon SNS).
Während dieses Prozesses stellt AWS Step Functions sicher, dass jede Lambda-Funktion in der richtigen Reihenfolge initiiert wird. Diese Zustandsmaschine kann parallel verarbeitet werden, um die Effizienz zu erhöhen. Ein Amazon S3 S3-Bucket fungiert als zentrales Speicher-Repository und unterstützt den Arbeitsablauf durch die Verwaltung der verschiedenen beteiligten Medien- und Dokumentenformate.
## Tools
**AWS-Services**
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) ist ein vollständig verwalteter Service, der Ihnen leistungsstarke Basismodelle (FMs) von führenden KI-Startups und Amazon über eine einheitliche API zur Verfügung stellt.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Er führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) unterstützt Sie bei der Koordination und Verwaltung des Nachrichtenaustauschs zwischen Herausgebern und Kunden, einschließlich Webservern und E-Mail-Adressen.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) ist ein serverloser Orchestrierungsservice, mit dem Sie AWS Lambda Lambda-Funktionen und andere AWS-Services kombinieren können, um geschäftskritische Anwendungen zu erstellen.
+ [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) ist ein automatischer Spracherkennungsdienst, der Modelle für maschinelles Lernen verwendet, um Audio in Text umzuwandeln.
**Andere Tools**
+ [LangChain](https://python.langchain.com/docs/get_started/introduction/)ist ein Framework für die Entwicklung von Anwendungen, die auf großen Sprachmodellen basieren (LLMs).
**Code-Repository**
Der Code für dieses Muster ist im GitHub [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)Repository verfügbar.
Das Code-Repository enthält die folgenden Dateien und Ordner:
+ `assets`Ordner — Die statischen Ressourcen für die Lösung, z. B. das Architekturdiagramm und der öffentliche Datensatz
+ `code/lambdas`folder — Der Python-Code für alle Lambda-Funktionen
+ `code/lambdas/generate`folder — Der Python-Code, der aus den zusammengefassten Daten im S3-Bucket ein Dokument generiert
+ `code/lambdas/preprocess`folder — Der Python-Code, der die Eingaben für die Step Functions Functions-Zustandsmaschine verarbeitet
+ `code/lambdas/summarize`folder — Der Python-Code, der die transkribierten Daten mithilfe des Amazon Bedrock-Service zusammenfasst
+ `code/lambdas/transcribe`folder — Der Python-Code, der Sprachdaten (Audiodatei) mithilfe von Amazon Transcribe in Text konvertiert
+ `code/lambdas/validate`folder — Der Python-Code, der überprüft, ob sich alle Antworten auf dasselbe Thema beziehen
+ `code/code_stack.py`— Die AWS-CDK-Konstrukt-Python-Datei, die zur Erstellung von AWS-Ressourcen verwendet wird
+ `app.py`— Die Python-Datei der AWS-CDK-App, die zur Bereitstellung von AWS-Ressourcen im AWS-Zielkonto verwendet wird
+ `requirements.txt`— Die Liste aller Python-Abhängigkeiten, die für das AWS-CDK installiert werden müssen
+ `cdk.json`— Die Eingabedatei zur Bereitstellung von Werten, die für die Erstellung von Ressourcen erforderlich sind
## Best Practices
Das bereitgestellte Codebeispiel dient nur proof-of-concept (PoC) oder Pilotzwecken. Wenn Sie die Lösung in der Produktion einsetzen möchten, wenden Sie die folgenden bewährten Methoden an:
+ [Amazon S3 S3-Zugriffsprotokollierung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html) aktivieren
+ [VPC-Flow-Logs](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html) aktivieren
## Epen
### AWS-Anmeldeinformationen auf Ihrer lokalen Workstation einrichten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Exportieren Sie Variablen für das Konto und die AWS-Region. | Führen Sie die folgenden Befehle aus, um AWS-Anmeldeinformationen für das AWS-CDK mithilfe von Umgebungsvariablen bereitzustellen.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps Ingenieur |
| Richten Sie das AWS-CLI mit dem Namen profile ein. | Um das benannte AWS-CLI-Profil für das Konto einzurichten, folgen Sie den Anweisungen unter [Konfiguration und Einstellungen der Anmeldeinformationsdatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). | AWS DevOps, DevOps Ingenieur |
### So richten Sie Ihre Umgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das Repo auf Ihre lokale Workstation. | Um das [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)Repository zu klonen, führen Sie den folgenden Befehl in Ihrem Terminal aus.git clone https://github.com/aws-samples/genai-knowledge-capture
| AWS DevOps, DevOps Ingenieur |
| (Optional) Ersetzen Sie die Audiodateien. | Gehen Sie wie folgt vor, um die Beispielanwendung so anzupassen, dass sie Ihre eigenen Daten einbezieht:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps Ingenieur |
| Richten Sie die virtuelle Python-Umgebung ein. | Führen Sie die folgenden Befehle aus, um die virtuelle Python-Umgebung einzurichten.cd genai-knowledge-capture
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
| AWS DevOps, DevOps Ingenieur |
| Synthetisieren Sie den AWS-CDK-Code. | Führen Sie den folgenden Befehl aus, um den Code in eine CloudFormation AWS-Stack-Konfiguration zu konvertieren.cdk synth
| AWS DevOps, DevOps Ingenieur |
### Konfiguration und Bereitstellung der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Stellen Sie den Zugriff auf das Basismodell bereit. | Aktivieren Sie den Zugriff auf das Modell Anthropic Claude 3 Sonnet für Ihr AWS-Konto. Anweisungen finden [Sie in der Bedrock-Dokumentation unter Modellzugriff hinzufügen](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-add). | AWS DevOps |
| Stellen Sie Ressourcen im Konto bereit. | Gehen Sie wie folgt vor, um Ressourcen im AWS-Konto mithilfe des AWS-CDK bereitzustellen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps Ingenieur |
| Abonnieren Sie das Amazon-SNS-Thema. | Gehen Sie wie folgt vor, um das Amazon SNS SNS-Thema für Benachrichtigungen zu abonnieren:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | Allgemeines AWS |
### Testen der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie die Zustandsmaschine aus. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | App-Entwickler, General AWS |
### Bereinigen Sie alle AWS-Ressourcen in der Lösung
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Entfernen Sie die AWS-Ressourcen. | Nachdem Sie die Lösung getestet haben, bereinigen Sie die Ressourcen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps Ingenieur |
## Zugehörige Ressourcen
**AWS-Dokumentation**
+ Ressourcen von Amazon Bedrock:
+ [Modellzugriff](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Inferenzparameter für Fundamentmodelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ AWS-CDK-Ressourcen:
+ [Erste Schritte mit dem AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Arbeiten mit dem AWS-CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Behebung häufiger AWS-CDK-Probleme](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Toolkit-Befehle](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-commands)
+ Ressourcen für AWS Step Functions:
+ [Erste Schritte mit AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started-with-sfn.html)
+ [Fehlersuche](https://docs.aws.amazon.com/step-functions/latest/dg/troubleshooting.html)
+ [Lambda-Funktionen mit Python erstellen](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Generativer KI-Anwendungsgenerator auf AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Sonstige Ressourcen**
+ [LangChain Dokumentation](https://python.langchain.com/docs/get_started/introduction)
# Generieren Sie mit Amazon Personalize personalisierte und neu eingestufte Empfehlungen
*Mason Cahill, Matthew Chasse und Tayo Olajide, Amazon Web Services*
## Zusammenfassung
Dieses Muster zeigt Ihnen, wie Sie Amazon Personalize verwenden, um personalisierte Empfehlungen — einschließlich neu eingestufter Empfehlungen — für Ihre Benutzer zu generieren, die auf der Erfassung von Benutzerinteraktionsdaten in Echtzeit von diesen Benutzern basieren. Das in diesem Muster verwendete Beispielszenario basiert auf einer Website zur Adoption von Haustieren, die anhand ihrer Interaktionen Empfehlungen für ihre Benutzer generiert (z. B. welche Haustiere ein Benutzer besucht). Anhand des Beispielszenarios lernen Sie, Amazon Kinesis Data Streams zur Erfassung von Interaktionsdaten, AWS Lambda zur Generierung von Empfehlungen und zur Neurangierung der Empfehlungen und Amazon Data Firehose zum Speichern der Daten in einem Amazon Simple Storage Service (Amazon S3) -Bucket zu verwenden. Sie lernen auch, AWS Step Functions zu verwenden, um eine Zustandsmaschine zu erstellen, die die Lösungsversion (d. h. ein trainiertes Modell) verwaltet, die Ihre Empfehlungen generiert.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives [AWS-Konto](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) mit einem [Bootstrapping des AWS](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) Cloud Development Kit (AWS CDK)
+ [AWS-Befehlszeilenschnittstelle (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) mit konfigurierten Anmeldeinformationen
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
**Produktversionen**
+ Python 3.9
+ AWS CDK 2.23.0 oder höher
+ AWS CLI 2.7.27 oder höher
## Architektur
**Technologie-Stack**
+ Amazon Data Firehose
+ Amazon Kinesis Data Streams
+ Amazon Personalize
+ Amazon Simple Storage Service (Amazon-S3)
+ AWS-Cloud-Entwicklungskit (AWS CDK)
+ AWS-Befehlszeilenschnittstelle (AWS Command Line Interface, AWS CLI)
+ AWS Lambda
+ AWS Step Functions
**Zielarchitektur**
Das folgende Diagramm zeigt eine Pipeline für die Aufnahme von Echtzeitdaten in Amazon Personalize. Die Pipeline verwendet diese Daten dann, um personalisierte und neu eingestufte Empfehlungen für Benutzer zu generieren.
![\[Architektur zur Datenaufnahme für Amazon Personalize\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/42eb193b-2347-408a-8b25-46beeb3b29ca/images/786dbd56-7d7f-41bb-90f6-d4485d73fe15.png)
Das Diagramm zeigt den folgenden Workflow:
1. Kinesis Data Streams nimmt Benutzerdaten in Echtzeit auf (z. B. Ereignisse wie besuchte Haustiere) zur Verarbeitung durch Lambda und Firehose.
1. Eine Lambda-Funktion verarbeitet die Datensätze aus Kinesis Data Streams und führt einen API-Aufruf durch, um die Benutzerinteraktion im Datensatz einem Event-Tracker in Amazon Personalize hinzuzufügen.
1. Eine zeitbasierte Regel ruft eine Step Functions Functions-Zustandsmaschine auf und generiert mithilfe der Ereignisse aus dem Event-Tracker in Amazon Personalize neue Lösungsversionen für die Empfehlungs- und Re-Ranking-Modelle.
1. Amazon Personalize [Personalize-Kampagnen](https://docs.aws.amazon.com/personalize/latest/dg/campaigns.html) werden von der State Machine aktualisiert, um die neue [Lösungsversion](https://docs.aws.amazon.com/personalize/latest/dg/creating-a-solution-version.html) zu verwenden.
1. Lambda ordnet die Liste der empfohlenen Artikel neu an, indem es die Amazon Personalize-Kampagne zur Neurangierung aufruft.
1. Lambda ruft die Liste der empfohlenen Artikel ab, indem es die Amazon Personalize Personalize-Empfehlungskampagne aufruft.
1. Firehose speichert die Ereignisse in einem S3-Bucket, wo sie als historische Daten abgerufen werden können.
## Tools
**AWS-Tools**
+ Das [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) ist ein Softwareentwicklungs-Framework, das Sie bei der Definition und Bereitstellung der AWS-Cloud-Infrastruktur im Code unterstützt.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit AWS-Services interagieren können.
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) unterstützt Sie bei der Bereitstellung von [Echtzeit-Streaming-Daten](https://aws.amazon.com/streaming-data/) an andere AWS-Services, benutzerdefinierte HTTP-Endpunkte und HTTP-Endpunkte, die von unterstützten Drittanbietern betrieben werden.
+ [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) hilft Ihnen dabei, große Datenströme in Echtzeit zu sammeln und zu verarbeiten.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Er führt Ihren Code nur bei Bedarf aus und skaliert automatisch, sodass Sie nur für die tatsächlich genutzte Rechenzeit zahlen.
+ [Amazon Personalize](https://docs.aws.amazon.com/personalize/latest/dg/what-is-personalize.html) ist ein vollständig verwalteter Service für maschinelles Lernen (ML), mit dem Sie auf der Grundlage Ihrer Daten Artikelempfehlungen für Ihre Benutzer generieren können.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) ist ein serverloser Orchestrierungsservice, mit dem Sie Lambda-Funktionen und andere AWS-Services kombinieren können, um geschäftskritische Anwendungen zu erstellen.
**Andere Tools**
+ [pytest](https://docs.pytest.org/en/7.2.x/index.html) ist ein Python-Framework zum Schreiben kleiner, lesbarer Tests.
+ [Python](https://www.python.org/) ist eine Allzweck-Computerprogrammiersprache.
**Code**
Der Code für dieses Muster ist im GitHub [Animal Recommender-Repository](https://github.com/aws-samples/personalize-pet-recommendations) verfügbar. Sie können die CloudFormation AWS-Vorlage aus diesem Repository verwenden, um die Ressourcen für die Beispiellösung bereitzustellen.
**Anmerkung**
Die Versionen der Amazon Personalize Personalize-Lösung, der Event Tracker und die Kampagnen werden durch [benutzerdefinierte Ressourcen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-custom-resources.html) (innerhalb der Infrastruktur) unterstützt, die die systemeigenen CloudFormation Ressourcen erweitern.
## Epen
### Schaffen Sie die Infrastruktur
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie eine isolierte Python-Umgebung. | **Mac/Linux-Setup**[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)**Windows-Setup**Um manuell eine virtuelle Umgebung zu erstellen, führen Sie den `% .venv\Scripts\activate.bat` Befehl von Ihrem Terminal aus. | DevOps Ingenieur |
| Synthetisieren Sie die CloudFormation Vorlage. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)`CDK_ENVIRONMENT`Bezieht sich in Schritt 2 auf die `config/{env}.yml` Datei. | DevOps Ingenieur |
| Stellen Sie Ressourcen bereit und schaffen Sie eine Infrastruktur. | Führen Sie den `./deploy.sh` Befehl von Ihrem Terminal aus aus, um die Lösungsressourcen bereitzustellen.Dieser Befehl installiert die erforderlichen Python-Abhängigkeiten. Ein Python-Skript erstellt einen S3-Bucket und einen AWS Key Management Service (AWS KMS) -Schlüssel und fügt dann die Startdaten für die ersten Modellerstellungen hinzu. Schließlich wird das Skript ausgeführt, `cdk deploy` um die verbleibende Infrastruktur zu erstellen.Das anfängliche Modelltraining findet während der Stack-Erstellung statt. Es kann bis zu zwei Stunden dauern, bis der Stack fertig erstellt ist. | DevOps Ingenieur |
## Zugehörige Ressourcen
+ [Tierempfehler](https://github.com/aws-samples/personalize-pet-recommendations) () GitHub
+ [AWS-CDK-Referenzdokumentation](https://docs.aws.amazon.com/cdk/api/v2/)
+ [Boto3-Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Optimieren Sie personalisierte Empfehlungen für eine Geschäftskennzahl Ihrer Wahl mit 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)
## Zusätzliche Informationen
**Beispiele für Payloads und Antworten**
*Empfehlung Lambda-Funktion*
Um Empfehlungen abzurufen, senden Sie eine Anfrage an die Lambda-Empfehlungsfunktion mit einer Nutzlast im folgenden Format:
```
{
"userId": "3578196281679609099",
"limit": 6
}
```
Die folgende Beispielantwort enthält eine Liste von Tiergruppen:
```
[{"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"},
```
Wenn Sie das `userId` Feld weglassen, gibt die Funktion allgemeine Empfehlungen zurück.
*Lambda-Funktion neu einordnen*
Um Re-Ranking zu verwenden, senden Sie eine Anfrage an die Lambda-Funktion zur Neurangierung. Die Payload enthält alle Elemente, `userId` die neu eingestuft werden IDs sollen, sowie deren Metadaten. In den folgenden Beispieldaten werden die Oxford Pets-Klassen für `animal_species_id` (1=Katze, 2=Hund) und die Ganzzahlen 1-5 für und verwendet: `animal_age_id` `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"
}
}
]
}
```
Die Lambda-Funktion ordnet diese Artikel neu ein und gibt dann eine geordnete Liste zurück, die den Artikel IDs und die direkte Antwort von Amazon Personalize enthält. Dies ist eine Rangliste der Tiergruppen, zu denen die Artikel gehören, und ihrer Punktzahl. Amazon Personalize verwendet Rezepte für [Benutzerpersonalisierung](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html) und [personalisiertes Ranking](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-search.html), um für jeden Artikel in den Empfehlungen eine Punktzahl anzugeben. Diese Werte stellen die relative Sicherheit dar, die Amazon Personalize darüber hat, welchen Artikel der Benutzer als Nächstes auswählen wird. Höhere Punktzahlen bedeuten eine größere Gewissheit.
```
{
"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"
}
}
```
*Amazon Kinesis Kinesis-Nutzlast*
Die an Amazon Kinesis zu sendende Nutzlast hat das folgende Format:
```
{
"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"
}
}
```
**Anmerkung**
Das `userId` Feld für einen nicht authentifizierten Benutzer wurde entfernt.
# Optimieren Sie mithilfe von SageMaker KI und Hydra Workflows für maschinelles Lernen — von der lokalen Entwicklung bis hin zu skalierbaren Experimenten
*David Sauerwein, Marco Geiger und Julian Ferdinand Grueber, Amazon Web Services*
## Zusammenfassung
Dieses Muster bietet einen einheitlichen Ansatz für die Konfiguration und Ausführung von Algorithmen für maschinelles Lernen (ML) von lokalen Tests bis hin zur Produktion auf Amazon SageMaker AI. ML-Algorithmen stehen im Mittelpunkt dieses Musters, aber sein Ansatz erstreckt sich auch auf Feature-Engineering, Inferenz und ganze ML-Pipelines. Dieses Muster veranschaulicht anhand eines Beispielanwendungsfalls den Übergang von der lokalen Skriptentwicklung zu SageMaker KI-Schulungsaufgaben.
Ein typischer ML-Workflow besteht darin, Lösungen auf einem lokalen Computer zu entwickeln und zu testen, groß angelegte Experimente (z. B. mit unterschiedlichen Parametern) in der Cloud durchzuführen und die genehmigte Lösung in der Cloud bereitzustellen. Anschließend muss die bereitgestellte Lösung überwacht und gewartet werden. Ohne einen einheitlichen Ansatz für diesen Workflow müssen Entwickler ihren Code häufig in jeder Phase neu gestalten. Wenn die Lösung von einer Vielzahl von Parametern abhängt, die sich in jeder Phase dieses Workflows ändern können, kann es immer schwieriger werden, organisiert und konsistent zu bleiben.
Dieses Muster adressiert diese Herausforderungen. Erstens macht es Code-Refactoring zwischen Umgebungen überflüssig, indem ein einheitlicher Workflow bereitgestellt wird, der konsistent bleibt, unabhängig davon, ob er auf lokalen Computern, in Containern oder auf SageMaker KI ausgeführt wird. Zweitens vereinfacht es die Parameterverwaltung durch das Konfigurationssystem von Hydra, bei dem Parameter in separaten Konfigurationsdateien definiert werden, die einfach geändert und kombiniert werden können, wobei die Konfiguration jedes Laufs automatisch protokolliert wird. Weitere Informationen darüber, wie dieses Muster diese Herausforderungen bewältigt, finden Sie unter [Zusätzliche Informationen](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional).
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktiver AWS-Konto
+ Eine AWS Identity and Access Management (IAM-) [Benutzerrolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) für die Bereitstellung und den Start der SageMaker KI-Schulungsjobs
+ AWS Command Line Interface [(AWS CLI) Version 2.0 oder höher [installiert](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) und konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ [Poetry](https://python-poetry.org/) Version 1.8 oder höher, aber früher als 2.0, installiert
+ [Docker](https://www.docker.com/) ist installiert
+ [Python-versie 3.10.x](https://www.python.org/downloads/release/python-31011/)
**Einschränkungen**
+ Der Code zielt derzeit nur auf SageMaker KI-Schulungsjobs ab. Es ist einfach, ihn auf die Verarbeitung von Jobs und ganzen SageMaker KI-Pipelines auszudehnen.
+ Für ein vollständig produktionsfähiges SageMaker KI-Setup müssen zusätzliche Details vorhanden sein. Beispiele könnten benutzerdefinierte AWS Key Management Service (AWS KMS) Schlüssel für Rechen- und Speicheranwendungen oder Netzwerkkonfigurationen sein. Sie können diese zusätzlichen Optionen auch konfigurieren, indem Sie Hydra in einem speziellen Unterordner des `config` Ordners verwenden.
+ Einige AWS-Services sind nicht in allen verfügbar. AWS-Regionen Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie unter [AWS Dienste nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus.
## Architektur
Das folgende Diagramm zeigt die Architektur der Lösung.
![\[Workflow zum Erstellen und Ausführen von SageMaker KI-Trainings- oder HPO-Jobs.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/1db57484-f85c-49a6-b870-471dade02b26/images/d80e7474-a975-4d92-8f66-2d34e33053fd.png)
Das Diagramm zeigt den folgenden Workflow:
1. Der Datenwissenschaftler kann den Algorithmus in kleinem Maßstab in einer lokalen Umgebung wiederholen, Parameter anpassen und das Trainingsskript schnell testen, ohne dass Docker oder KI erforderlich sind. SageMaker (Weitere Informationen finden Sie unter der Aufgabe „Lokal für schnelle Tests ausführen“ in [Epics](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics).)
1. Sobald der Datenwissenschaftler mit dem Algorithmus zufrieden ist, erstellt er das Docker-Image und überträgt es in das angegebene Amazon Elastic Container Registry (Amazon ECR) -Repository. `hydra-sm-artifact` [(Weitere Informationen finden Sie unter „Workflows auf SageMaker KI ausführen“ in Epics.)](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics)
1. Der Datenwissenschaftler initiiert entweder SageMaker KI-Trainingsjobs oder Hyperparameter-Optimierungsjobs (HPO) mithilfe von Python-Skripten. Für reguläre Trainingsjobs wird die angepasste Konfiguration in den Amazon Simple Storage Service (Amazon S3) Bucket mit dem Namen geschrieben`hydra-sample-config`. Für HPO-Jobs wird der Standardkonfigurationssatz angewendet, der sich im `config` Ordner befindet.
1. Der SageMaker KI-Trainingsjob ruft das Docker-Image ab, liest die Eingabedaten aus dem Amazon S3 S3-Bucket `hydra-sample-data` und ruft entweder die Konfiguration aus dem Amazon S3 S3-Bucket ab `hydra-sample-config` oder verwendet die Standardkonfiguration. Nach dem Training speichert der Job die Ausgabedaten im Amazon S3 S3-Bucket`hydra-sample-data`.
**Automatisierung und Skalierung**
+ [Für automatisierte Schulungen, Umschulungen oder Inferenzen können Sie den AWS CLI Code in Dienste wie [AWS Lambda[AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), oder Amazon integrieren. EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html)
+ Die Skalierung kann erreicht werden, indem Konfigurationen für die Instance-Größen geändert oder Konfigurationen für verteilte Schulungen hinzugefügt werden.
## Tools
**AWS-Services**
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)hilft Ihnen dabei, AWS Ressourcen einzurichten, sie schnell und konsistent bereitzustellen und sie während ihres gesamten Lebenszyklus über AWS-Konten und zu verwalten AWS-Regionen.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können. Für dieses Muster AWS CLI ist das sowohl für die anfängliche Konfiguration als auch für das Testen von Ressourcen nützlich.
+ [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) ist ein verwalteter Container-Image-Registry-Service, der sicher, skalierbar und zuverlässig ist.
+ [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) ist ein verwalteter Service für maschinelles Lernen (ML), mit dem Sie ML-Modelle erstellen und trainieren und diese dann in einer produktionsbereiten, gehosteten Umgebung bereitstellen können. SageMaker AI Training ist ein vollständig verwalteter ML-Service innerhalb von SageMaker KI, der das Training von ML-Modellen in großem Maßstab ermöglicht. Das Tool kann die Rechenanforderungen von Trainingsmodellen effizient bewältigen und nutzt dabei die integrierte Skalierbarkeit und Integration mit anderen AWS-Services Modellen. SageMaker AI Training unterstützt auch benutzerdefinierte Algorithmen und Container und ist somit flexibel für eine Vielzahl von ML-Workflows.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) ist ein cloudbasierter Objektspeicherservice, der Sie beim Speichern, Schützen und Abrufen beliebiger Datenmengen unterstützt.
**Andere Tools**
+ [Docker](https://www.docker.com/) ist eine Reihe von Platform-as-a-Service (PaaS) -Produkten, die Virtualisierung auf Betriebssystemebene nutzen, um Software in Containern bereitzustellen. Es wurde in diesem Muster verwendet, um konsistente Umgebungen in verschiedenen Phasen sicherzustellen, von der Entwicklung bis zur Bereitstellung, und um Abhängigkeiten und Code zuverlässig zu verpacken. Die Containerisierung von Docker ermöglichte eine einfache Skalierung und Versionskontrolle im gesamten Workflow.
+ [Hydra ist ein](https://hydra.cc/) Konfigurationsmanagement-Tool, das Flexibilität bei der Handhabung mehrerer Konfigurationen und dynamisches Ressourcenmanagement bietet. Es ist entscheidend für die Verwaltung von Umgebungskonfigurationen und ermöglicht eine nahtlose Bereitstellung in verschiedenen Umgebungen. Weitere Informationen zu Hydra finden Sie unter [Zusätzliche Informationen](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional).
+ [Python](https://www.python.org/) ist eine Allzweck-Computerprogrammiersprache. Python wurde verwendet, um den ML-Code und den Deployment-Workflow zu schreiben.
+ [Poetry](https://python-poetry.org/) ist ein Tool für Abhängigkeitsmanagement und Paketierung in Python.
**Code-Repository**
Der Code für dieses Muster ist im Repository GitHub [configuring-sagemaker-training-jobs-with-hydra](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra) verfügbar.
## Best Practices
+ Wählen Sie eine IAM-Rolle für die Bereitstellung und den Start der SageMaker KI-Schulungsjobs, die dem Prinzip der geringsten Rechte folgt, und gewähren Sie die Mindestberechtigungen, die zur Ausführung einer Aufgabe erforderlich sind. Weitere Informationen finden Sie in der IAM-Dokumentation unter [Gewährung der geringsten Rechte](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) und [bewährte Methoden zur Sicherheit](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).
+ Verwenden Sie temporäre Anmeldeinformationen, um auf die IAM-Rolle im Terminal zuzugreifen.
## Epen
### Richte die Umgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen und aktivieren Sie die virtuelle Umgebung. | Um die virtuelle Umgebung zu erstellen und zu aktivieren, führen Sie die folgenden Befehle im Stammverzeichnis des Repositorys aus:poetry install
poetry shell
| Allgemeines AWS |
| Stellen Sie die Infrastruktur bereit. | Führen Sie den folgenden Befehl aus CloudFormation, um die Infrastruktur mithilfe von bereitzustellen:aws cloudformation deploy --template-file infra/hydra-sagemaker-setup.yaml --stack-name hydra-sagemaker-setup --capabilities CAPABILITY_NAMED_IAM
| General AWS, DevOps Ingenieur |
| Laden Sie die Beispieldaten herunter. | Führen Sie den folgenden Befehl aus, um die Eingabedaten von [openml](https://www.openml.org/) auf Ihren lokalen Computer herunterzuladen:python scripts/download_data.py
| Allgemeines AWS |
| Für schnelle Tests lokal ausführen. | Führen Sie den folgenden Befehl aus, um den Trainingscode lokal zum Testen auszuführen:python mypackage/train.py data.train_data_path=data/train.csv evaluation.base_dir_path=data
Die Protokolle aller Ausführungen werden nach Ausführungszeit sortiert in einem Ordner mit dem Namen `outputs` gespeichert. Weitere Informationen finden Sie im Abschnitt „Ausgabe“ im [GitHub Repository](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra).Mithilfe der `--multirun` Funktionalität können Sie auch mehrere Schulungen parallel mit unterschiedlichen Parametern durchführen. Weitere Informationen finden Sie in der [Hydra-Dokumentation](https://hydra.cc/docs/tutorials/basic/running_your_app/multi-run/). | Datenwissenschaftler |
### Führen Sie Workflows auf KI SageMaker aus
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Legen Sie die Umgebungsvariablen fest. | Um Ihren Job auf SageMaker KI auszuführen, legen Sie die folgenden Umgebungsvariablen fest und geben Sie dabei Ihre ID AWS-Region und Ihre AWS-Konto ID an: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/
| Allgemeines AWS |
| Erstellen Sie ein Docker-Image und übertragen Sie es. | Führen Sie den folgenden Befehl aus, um das Docker-Image zu erstellen und in das Amazon ECR-Repository zu übertragen:chmod +x scripts/create_and_push_image.sh
scripts/create_and_push_image.sh $ECR_REPO_NAME $image_tag $AWS_REGION $ACCOUNT_ID
Bei dieser Aufgabe wird davon ausgegangen, dass Sie in Ihrer Umgebung über gültige Anmeldeinformationen verfügen. Das Docker-Image wird in das Amazon ECR-Repository übertragen, das in der vorherigen Aufgabe in der Umgebungsvariablen angegeben wurde, und wird verwendet, um den SageMaker AI-Container zu aktivieren, in dem der Trainingsjob ausgeführt wird. | ML-Ingenieur, General AWS |
| Kopieren Sie die Eingabedaten nach Amazon S3. | Der SageMaker KI-Trainingsjob muss die Eingabedaten aufnehmen. Führen Sie den folgenden Befehl aus, um die Eingabedaten in den Amazon S3 S3-Bucket für Daten zu kopieren: aws s3 cp data/train.csv "${INPUT_DATA_S3_PATH}train.csv" | Dateningenieur, General AWS |
| Reichen Sie SageMaker KI-Schulungsjobs ein. | Um die Ausführung Ihrer Skripts zu vereinfachen, geben Sie in der `default.yaml` Datei die Standardkonfigurationsparameter an. Dieser Ansatz gewährleistet nicht nur die Konsistenz zwischen den Ausführungen, sondern bietet auch die Flexibilität, die Standardeinstellungen bei Bedarf einfach zu überschreiben. Sehen Sie sich das folgende Beispiel an: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
| Allgemeiner AWS, ML-Ingenieur, Datenwissenschaftler |
| Führen Sie das SageMaker KI-Hyperparameter-Tuning durch. | Das Ausführen des SageMaker KI-Hyperparameter-Tunings ähnelt dem Einreichen eines SageMaker AII-Trainingsjobs. Das Ausführungsskript unterscheidet sich jedoch in einigen wichtigen Punkten, wie Sie in der [Datei start\$1sagemaker\$1hpo\$1job.py](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra/blob/main/scripts/start_sagemaker_hpo_job.py) sehen können. Die zu optimierenden Hyperparameter müssen über die boto3-Nutzlast und nicht über einen Kanal an den Trainingsjob weitergeleitet werden.Führen Sie die folgenden Befehle aus, um den Job zur Hyperparameter-Optimierung (HPO) zu starten: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
| Datenwissenschaftler |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| Abgelaufenes Token | Exportieren Sie neue Anmeldeinformationen AWS . |
| Fehlende IAM-Berechtigungen | Stellen Sie sicher, dass Sie die Anmeldeinformationen einer IAM-Rolle exportieren, die über alle erforderlichen IAM-Berechtigungen verfügt, um die CloudFormation Vorlage bereitzustellen und die SageMaker KI-Schulungsjobs zu starten. |
## Zugehörige Ressourcen
+ [Trainieren Sie ein Modell mit Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) (AWS Dokumentation)
+ [Was ist Hyperparameter-Tuning?](https://aws.amazon.com/what-is/hyperparameter-tuning/#:~:text=Hyperparameter%20tuning%20allows%20data%20scientists,the%20model%20as%20a%20hyperparameter.)
## Zusätzliche Informationen
Dieses Muster befasst sich mit den folgenden Herausforderungen:
**Konsistenz von der lokalen Entwicklung bis zur Bereitstellung im großen Maßstab** — Mit diesem Muster können Entwickler denselben Workflow verwenden, unabhängig davon, ob sie lokale Python-Skripte verwenden, lokale Docker-Container ausführen, große SageMaker KI-Experimente durchführen oder in der Produktion auf SageMaker KI bereitstellen. Diese Konsistenz ist aus den folgenden Gründen wichtig:
+ **Schnellere Iteration** — Sie ermöglicht schnelles, lokales Experimentieren, ohne dass größere Anpassungen bei der Skalierung erforderlich sind.
+ **Kein Refactoring** — Der Übergang zu größeren Experimenten mit SageMaker KI ist nahtlos und erfordert keine Überarbeitung des bestehenden Setups.
+ **Kontinuierliche Verbesserung** — Die Entwicklung neuer Funktionen und die kontinuierliche Verbesserung des Algorithmus sind unkompliziert, da der Code in allen Umgebungen gleich bleibt.
**Konfigurationsmanagement** — Dieses Muster nutzt [Hydra, ein](https://hydra.cc/) Konfigurationsmanagement-Tool, um die folgenden Vorteile zu bieten:
+ Parameter werden getrennt vom Code in Konfigurationsdateien definiert.
+ Verschiedene Parametersätze können einfach ausgetauscht oder kombiniert werden.
+ Die Nachverfolgung von Experimenten wird vereinfacht, da die Konfiguration jedes Durchlaufs automatisch protokolliert wird.
+ Cloud-Experimente können dieselbe Konfigurationsstruktur wie lokale Läufe verwenden, wodurch Konsistenz gewährleistet wird.
Mit Hydra können Sie die Konfiguration effektiv verwalten und die folgenden Funktionen aktivieren:
+ **Konfigurationen aufteilen** — Teilen Sie Ihre Projektkonfigurationen in kleinere, überschaubare Teile auf, die unabhängig voneinander geändert werden können. Dieser Ansatz erleichtert die Bearbeitung komplexer Projekte.
+ **Einfache Anpassung der Standardeinstellungen** — Ändern Sie Ihre Basiskonfigurationen schnell, sodass Sie neue Ideen leichter testen können.
+ **CLI-Eingaben und Konfigurationsdateien aufeinander abstimmen** — Kombinieren Sie Befehlszeileneingaben problemlos mit Ihren Konfigurationsdateien. Dieser Ansatz reduziert Unordnung und Verwirrung und macht Ihr Projekt im Laufe der Zeit überschaubarer.
# Translate natürliche Sprache in Abfragen, DSL für OpenSearch und Elasticsearch-Abfragen
*Tabby Ward, Nicholas Switzer und Breanne Warner, Amazon Web Services*
## Zusammenfassung
Dieses Muster zeigt, wie umfangreiche Sprachmodelle (LLMs) verwendet werden können, um Abfragen in natürlicher Sprache in abfragedomänenspezifische Sprache (Query DSL) umzuwandeln, was es Benutzern erleichtert, mit Suchdiensten wie OpenSearch Elasticsearch zu interagieren, auch ohne umfangreiche Kenntnisse der Abfragesprache zu benötigen. Diese Ressource ist besonders wertvoll für Entwickler und Datenwissenschaftler, die suchbasierte Anwendungen mit Funktionen für Abfragen in natürlicher Sprache erweitern und so letztlich die Benutzererfahrung und die Suchfunktionen verbessern möchten.
Das Muster veranschaulicht Techniken für schnelles Engineering, iterative Verfeinerung und Einbindung von Fachwissen, die allesamt für die Generierung synthetischer Daten von entscheidender Bedeutung sind. Dieser Ansatz konzentriert sich zwar in erster Linie auf die Konvertierung von Abfragen, zeigt aber implizit das Potenzial für Datenerweiterung und skalierbare synthetische Datenproduktion. Diese Grundlage könnte auf umfassendere Aufgaben zur Generierung synthetischer Daten ausgedehnt werden, um zu verdeutlichen, wie wichtig es ist, unstrukturierte Eingaben LLMs in natürlicher Sprache mit strukturierten, anwendungsspezifischen Ausgaben zu verbinden.
Diese Lösung beinhaltet keine Migrations- oder Bereitstellungstools im herkömmlichen Sinne. Stattdessen konzentriert sie sich auf die Demonstration eines Machbarkeitsnachweises (Proof of Concept, PoC) für die Konvertierung von Abfragen in natürlicher Sprache in Abfragen von DSL mithilfe von. LLMs
+ Das Muster verwendet ein Jupyter-Notizbuch als step-by-step Leitfaden für die Einrichtung der Umgebung und die Implementierung der Konvertierung. text-to-query
+ Es verwendet Amazon Bedrock für den Zugriff LLMs, die für die Interpretation natürlicher Sprache und die Generierung entsprechender Abfragen von entscheidender Bedeutung sind.
+ Die Lösung ist für die Zusammenarbeit mit Amazon OpenSearch Service konzipiert. Sie können einem ähnlichen Prozess für Elasticsearch folgen, und die generierten Abfragen könnten möglicherweise für ähnliche Suchmaschinen angepasst werden.
[Query DSL](https://opensearch.org/docs/latest/query-dsl/) ist eine flexible, JSON-basierte Suchsprache, mit der komplexe Abfragen sowohl in Elasticsearch als auch erstellt werden. OpenSearch Sie ermöglicht es Ihnen, Abfragen in den Abfrageparametern von Suchoperationen anzugeben, und unterstützt verschiedene Abfragetypen. Eine DSL-Abfrage umfasst Blattabfragen und zusammengesetzte Abfragen. Blattabfragen suchen nach bestimmten Werten in bestimmten Feldern und umfassen Volltext-, Begriffsebene-, geografische, verbindende, bereichsübergreifende und spezielle Abfragen. Zusammengesetzte Abfragen dienen als Wrapper für mehrere Blatt- oder zusammengesetzte Klauseln und kombinieren ihre Ergebnisse oder ändern ihr Verhalten. Query DSL unterstützt die Erstellung anspruchsvoller Suchanfragen, die von einfachen Abfragen, die alle Kriterien erfüllen, bis hin zu komplexen Abfragen mit mehreren Klauseln reichen, die zu hochspezifischen Ergebnissen führen. Query DSL ist besonders nützlich für Projekte, die erweiterte Suchfunktionen, flexible Abfragekonstruktion und JSON-basierte Abfragestrukturen erfordern.
Dieses Muster verwendet Techniken wie „Few-Shot Prompting“, Systemaufforderungen, strukturierte Ausgabe, Verkettung von Eingabeaufforderungen, Kontextbereitstellung und aufgabenspezifische Eingabeaufforderungen für die DSL-Konvertierung. text-to-query [Definitionen und Beispiele für diese Techniken finden Sie im Abschnitt Zusätzliche Informationen.](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional)
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
Um das Jupyter-Notebook effektiv für die Konvertierung von Abfragen in natürlicher Sprache in DSL-Abfragen zu verwenden, benötigen Sie:
+ **Vertrautheit mit Jupyter-Notebooks**. Grundlegendes Verständnis der Navigation und Ausführung von Code in einer Jupyter-Notebook-Umgebung.
+ **Python-Umgebung**. Eine funktionierende Python-Umgebung, vorzugsweise Python 3.x, in der die erforderlichen Bibliotheken installiert sind.
+ **Elasticsearch oder Wissen OpenSearch **. Grundkenntnisse in Elasticsearch oder OpenSearch, einschließlich seiner Architektur und der Durchführung von Abfragen.
+ **AWS-Konto**. Aktiv AWS-Konto für den Zugriff auf Amazon Bedrock und andere verwandte Dienste.
+ **Bibliotheken und Abhängigkeiten**. Installation bestimmter Bibliotheken, die im Notizbuch erwähnt werden, z. B. `boto3` für die AWS Interaktion, und aller anderen Abhängigkeiten, die für die LLM-Integration erforderlich sind.
+ **Modellieren Sie den Zugriff innerhalb von Amazon Bedrock**. Dieses Muster verwendet drei Claude LLMs von Anthropic. Öffnen Sie die [Amazon Bedrock-Konsole](https://console.aws.amazon.com/bedrock/) und wählen Sie **Modellzugriff**. Wählen Sie auf dem nächsten Bildschirm die Option **Bestimmte Modelle aktivieren** und wählen Sie diese drei Modelle aus:
+ Claude 3 Sonnet
+ Claude 3.5 Sonett
+ Claude 3 Haiku
+ **Richtige IAM-Richtlinien und IAM-Rolle**. Um das Notebook in Ihrer AWS Identity and Access Management (IAM-) Rolle ausführen zu können AWS-Konto, benötigen Sie die `SagemakerFullAccess` Richtlinie sowie die Richtlinie, die im Abschnitt [Zusätzliche Informationen](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional) angegeben ist, den Sie benennen können. `APGtext2querydslpolicy` Diese Richtlinie beinhaltet das Abonnieren der drei aufgeführten Claude-Modelle.
Wenn diese Voraussetzungen erfüllt sind, wird ein reibungsloser Ablauf bei der Arbeit mit dem Notebook und der Implementierung der text-to-query Funktionen gewährleistet.
**Einschränkungen**
+ **Status des Machbarkeitsnachweises**. Dieses Projekt ist in erster Linie als Machbarkeitsnachweis (PoC) gedacht. Es zeigt das Potenzial der Umwandlung von Abfragen LLMs in natürlicher Sprache in Query-DSL, ist jedoch möglicherweise nicht vollständig optimiert oder produktionsbereit.
+ **Einschränkungen des Modells:**
**Einschränkungen des Kontextfensters***.* Beachten Sie bei der Verwendung der LLMs auf Amazon Bedrock verfügbaren Funktionen die Einschränkungen des Kontextfensters:
Claude-Modelle (Stand September 2024):
+ Claude 3 Opus: 200.000 Tokens
+ Claude 3 Sonnet: 200.000 Wertmarken
+ Claude 3 Haiku: 200.000 Tokens
Andere Modelle auf Amazon Bedrock haben möglicherweise andere Kontextfenstergrößen. Die neuesten Informationen finden Sie immer in der neuesten Dokumentation.
**Verfügbarkeit des Modells***.*Die Verfügbarkeit bestimmter Modelle bei Amazon Bedrock kann variieren. Stellen Sie sicher, dass Sie Zugriff auf die erforderlichen Modelle haben, bevor Sie diese Lösung implementieren.
+ **Zusätzliche Einschränkungen**
+ **Komplexität der Abfrage**. Die Effektivität der DSL-Konvertierung von natürlicher Sprache zur Abfrage kann je nach Komplexität der Eingabeabfrage variieren.
+ **Versionskompatibilität**. Die generierte DSL-Abfrage erfordert möglicherweise Anpassungen, die auf der spezifischen Version von Elasticsearch oder OpenSearch der von Ihnen verwendeten Version basieren.
+ **Leistung.** Dieses Muster bietet eine PoC-Implementierung, sodass die Geschwindigkeit und Genauigkeit der Abfragegenerierung für den Einsatz in großen Produktionsmengen möglicherweise nicht optimal sind.
+ **Kosten**. Die Verwendung LLMs in Amazon Bedrock ist kostenpflichtig. Beachten Sie die Preisstruktur für das von Ihnen gewählte Modell. Weitere Informationen finden Sie unter [Amazon Bedrock – Preise](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html).
+ **Wartung**. Regelmäßige Aktualisierungen der Eingabeaufforderungen und der Modellauswahl sind möglicherweise erforderlich, um mit den Fortschritten in der LLM-Technologie und den Änderungen der Abfrage-DSL-Syntax Schritt zu halten.
**Produktversionen**
Diese Lösung wurde in Amazon OpenSearch Service getestet. Wenn Sie Elasticsearch verwenden möchten, müssen Sie möglicherweise einige Änderungen vornehmen, um die genaue Funktionalität dieses Musters zu replizieren.
+ **OpenSearch Versionskompatibilität**. **OpenSearch **behält die Abwärtskompatibilität innerhalb der Hauptversionen bei. Beispiel:
+ OpenSearch 1.x-Clients sind im Allgemeinen mit OpenSearch 1.x-Clustern kompatibel.
+ OpenSearch 2.x-Clients sind im Allgemeinen mit 2.x-Clustern kompatibel OpenSearch .
Es ist jedoch immer am besten, wenn möglich dieselbe Nebenversion für Client und Cluster zu verwenden.
+ **OpenSearch API-Kompatibilität**. **OpenSearch **behält die API-Kompatibilität mit Elasticsearch OSS 7.10.2 für die meisten Operationen bei. Es gibt jedoch einige Unterschiede, insbesondere in neueren Versionen.
+ **OpenSearch Überlegungen zum Upgrade**:
+ Direkte Downgrades werden nicht unterstützt. Verwenden Sie bei Bedarf Snapshots für das Rollback.
+ Wenn Sie ein Upgrade durchführen, überprüfen Sie die [Kompatibilitätsmatrix und die Versionshinweise](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-operations.html) auf wichtige Änderungen.
**Überlegungen zu Elasticsearch**
+ **Elasticsearch-Version**. Die Hauptversion von Elasticsearch, die Sie verwenden, ist entscheidend, da sich die Abfragesyntax und die Funktionen zwischen den Hauptversionen ändern können. Derzeit ist Elasticsearch 8.x die neueste stabile Version. Stellen Sie sicher, dass Ihre Abfragen mit Ihrer spezifischen Elasticsearch-Version kompatibel sind.
+ Version der **Elasticsearch-Abfrage der DSL-Bibliothek.** Wenn Sie die Elasticsearch-Query-DSL-Python-Bibliothek verwenden, stellen Sie sicher, dass ihre Version mit Ihrer Elasticsearch-Version übereinstimmt. Beispiel:
+ Verwenden Sie für Elasticsearch 8.x eine `elasticsearch-dsl` Version, die größer oder gleich 8.0.0, aber kleiner als 9.0.0 ist.
+ Verwenden Sie für Elasticsearch 7.x eine `elasticsearch-dsl` Version, die größer oder gleich 7.0.0, aber kleiner als 8.0.0 ist.
+ **Version der Client-Bibliothek.** Egal, ob Sie den offiziellen Elasticsearch-Client oder einen sprachspezifischen Client verwenden, stellen Sie sicher, dass er mit Ihrer Elasticsearch-Version kompatibel ist.
+ **Fragen Sie die DSL-Version ab.** Query DSL entwickelt sich mit den Elasticsearch-Versionen weiter. Einige Abfragetypen oder Parameter sind möglicherweise veraltet oder wurden in anderen Versionen eingeführt.
+ **Version zuordnen**. Die Art und Weise, wie Sie Zuordnungen für Ihre Indizes definieren und zwischen Versionen wechseln. Schauen Sie immer in der Mapping-Dokumentation für Ihre spezifische Elasticsearch-Version nach.
+ **Versionen der Analysetools**. Wenn Sie Analyzer, Tokenizer oder andere Textanalysetools verwenden, kann sich deren Verhalten oder Verfügbarkeit zwischen den Versionen ändern.
## Architektur
**Zielarchitektur**
Das folgende Diagramm veranschaulicht die Architektur für dieses Muster.
![\[Architektur für die Übersetzung natürlicher Sprache zur DSL-Abfrage in Amazon Bedrock.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/75296405-2893-4328-9551-9bcc6ec7fd3e/images/ffb1b893-d23c-4e1c-b679-8063b4f85a8a.png)
Wobei:
1. Benutzereingabe und Systemaufforderung mit einigen Beispielen für Eingabeaufforderungen. Der Prozess beginnt mit einem Benutzer, der eine Abfrage in natürlicher Sprache oder eine Anfrage zur Schemagenerierung bereitstellt.
1. Amazon Bedrock Die Eingabe wird an Amazon Bedrock gesendet, das als Schnittstelle für den Zugriff auf das Claude LLM dient.
1. Claude 3 Sonnet LLM. Amazon Bedrock verwendet Claude 3 Sonnet aus der Claude 3-Familie von, um die LLMs Eingabe zu verarbeiten. Es interpretiert und generiert die entsprechende Elasticsearch- oder Query-DSL. OpenSearch Für Schemaanfragen generiert es synthetische Elasticsearch- oder Mappings. OpenSearch
1. DSL-Generierung abfragen. Bei Abfragen in natürlicher Sprache verwendet die Anwendung die Ausgabe des LLM und formatiert sie in eine gültige Elasticsearch- oder OpenSearch Service-Abfrage-DSL.
1. Generierung synthetischer Daten. Die Anwendung verwendet auch Schemas, um synthetisches Elasticsearch zu erstellen, oder OpenSearch Daten, die zu Testzwecken in eine OpenSearch serverlose Sammlung geladen werden.
1. OpenSearch oder Elasticsearch. Die generierte Query-DSL wird anhand einer OpenSearch serverlosen Sammlung für alle Indizes abgefragt. Die JSON-Ausgabe enthält die relevanten Daten und die Anzahl der *Treffer* aus den Daten, die sich in der Serverless-Sammlung befinden. OpenSearch
**Automatisierung und Skalierung**
Der Code, der mit diesem Muster bereitgestellt wird, wurde ausschließlich für PoC-Zwecke erstellt. Die folgende Liste enthält einige Vorschläge zur weiteren Automatisierung und Skalierung der Lösung und zur Umstellung des Codes auf die Serienproduktion. Diese Verbesserungen liegen außerhalb des Geltungsbereichs dieses Musters.
+ Containerisierung:
+ Dockerisieren Sie die Anwendung, um die Konsistenz in verschiedenen Umgebungen sicherzustellen.
+ Verwenden Sie Container-Orchestrierungsplattformen wie Amazon Elastic Container Service (Amazon ECS) oder Kubernetes für skalierbare Bereitstellungen.
+ Serverlose Architektur:
+ Wandeln Sie die Kernfunktionen in AWS Lambda Funktionen um.
+ Verwenden Sie Amazon API Gateway, um RESTful Endpunkte für die Eingabe von Abfragen in natürlicher Sprache zu erstellen.
+ Asynchrone Verarbeitung:
+ Implementieren Sie Amazon Simple Queue Service (Amazon SQS), um eingehende Anfragen in die Warteschlange zu stellen.
+ Wird verwendet AWS Step Functions , um den Arbeitsablauf bei der Verarbeitung von Abfragen und der Generierung von Abfrage-DSL zu orchestrieren.
+ Zwischenspeichern:
+ Implementieren Sie einen Mechanismus zum Zwischenspeichern der Eingabeaufforderungen.
+ Überwachung und Protokollierung:
+ Verwenden Sie Amazon CloudWatch für die Überwachung und Benachrichtigung.
+ Implementieren Sie eine zentrale Protokollierung mit Amazon CloudWatch Logs oder Amazon OpenSearch Service für Protokollanalysen.
+ Verbesserungen der Sicherheit:
+ Implementieren Sie IAM-Rollen für eine differenzierte Zugriffskontrolle.
+ Wird verwendet AWS Secrets Manager , um API-Schlüssel und Anmeldeinformationen sicher zu speichern und zu verwalten.
+ Einsatz in mehreren Regionen:
+ Erwägen Sie den Einsatz der Lösung auf mehreren Ebenen, AWS-Regionen um die Latenz zu verbessern und die Notfallwiederherstellung zu verbessern.
+ Verwenden Sie Amazon Route 53 für intelligentes Routing von Anfragen.
Durch die Implementierung dieser Vorschläge können Sie diesen PoC in eine robuste, skalierbare und produktionsreife Lösung umwandeln. Wir empfehlen Ihnen, jede Komponente und das gesamte System vor der vollständigen Bereitstellung gründlich zu testen.
## Tools
**Tools**
+ [Amazon SageMaker AI-Notebooks](https://aws.amazon.com/sagemaker/notebooks/) sind vollständig verwaltete Jupyter-Notebooks für die Entwicklung von maschinellem Lernen. Dieses Muster verwendet Notizbücher als interaktive Umgebung für die Datenexploration, Modellentwicklung und Experimente in Amazon SageMaker AI. Notebooks bieten eine nahtlose Integration mit anderen SageMaker KI-Funktionen und AWS-Services.
+ [Python](https://www.python.org/) ist eine Allzweck-Computerprogrammiersprache. Dieses Muster verwendet Python als Kernsprache für die Implementierung der Lösung.
+ [Amazon Bedrock](https://aws.amazon.com/bedrock/) ist ein vollständig verwalteter Service, der Ihnen leistungsstarke Basismodelle (FMs) von führenden KI-Startups und Amazon über eine einheitliche API zur Verfügung stellt. Amazon Bedrock bietet Zugriff auf LLMs für die Verarbeitung natürlicher Sprache. Dieses Muster verwendet Modelle von Anthropic Claude 3.
+ [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)ist ein Software-Entwicklungskit, mit dem Sie Ihre Python-Anwendung, -Bibliothek oder Ihr Python-Skript integrieren können AWS-Services, einschließlich Amazon Bedrock.
+ [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) ist ein verwalteter Service, der Sie bei der Bereitstellung, dem Betrieb und der Skalierung von OpenSearch Service-Clustern in der AWS-Cloud unterstützt. Dieses Muster verwendet OpenSearch Service als Zielsystem für die Generierung von Abfrage-DSL.
**Code-Repository**
Der Code für dieses Muster ist im Repository GitHub [Prompt Engineering Text-to-QueryDSL Using Claude 3 Models](https://github.com/aws-samples/text-to-queryDSL/blob/main/text2ES_prompting_guide.ipynb) verfügbar. In dem Beispiel wird eine Gesundheits-App für soziale Medien verwendet, die Beiträge für Benutzer und Benutzerprofile erstellt, die mit der Gesundheitsanwendung verknüpft sind.
## Best Practices
Beachten Sie bei der Arbeit mit dieser Lösung Folgendes:
+ Für den Zugriff auf Amazon Bedrock sind die richtigen AWS Anmeldeinformationen und Berechtigungen erforderlich
+ Mögliche Kosten im Zusammenhang mit der Nutzung von AWS-Services und LLMs
+ Wie wichtig es ist, sich mit Query-DSL vertraut zu machen, um die generierten Abfragen zu validieren und gegebenenfalls zu modifizieren
## Epen
### Richten Sie die Umgebung ein und bereiten Sie die Daten vor
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Richten Sie die Entwicklungsumgebung ein. | Detaillierte Anweisungen und Code für diesen und die anderen Schritte in diesem Muster finden Sie in der umfassenden exemplarischen Vorgehensweise im [GitHub Repository](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/de_de/prescriptive-guidance/latest/patterns/translate-natural-language-query-dsl-opensearch-elasticsearch.html) | Python, Pip, AWS-SDK |
| AWS Zugriff einrichten. | Richten Sie den Amazon Bedrock-Client und die SageMaker KI-Sitzung ein. Rufen Sie den Amazon-Ressourcennamen (ARN) für die SageMaker AI-Ausführungsrolle ab, um ihn später bei der Erstellung der OpenSearch Serverless-Sammlung zu verwenden. | IAM, AWS-CLI, Amazon Bedrock, Amazon SageMaker |
| Laden Sie Schemas für Gesundheits-Apps. | Lesen und analysieren Sie JSON-Schemas für Gesundheitsposts und Benutzerprofile aus vordefinierten Dateien. Konvertiert Schemas in Zeichenketten für die spätere Verwendung in Eingabeaufforderungen. | DevOps Ingenieur, allgemein AWS, Python, JSON |
### Generieren Sie synthetische Daten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen LLM-basierten Datengenerator. | Implementieren Sie die Funktion **generate\$1data ()**, um die Amazon Bedrock Converse-API mit Claude 3-Modellen aufzurufen. Modell IDs für Sonnet, Sonnet 3.5 und Haiku einrichten: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, Amazon Bedrock API, LLM-Aufforderung |
| Erstellen Sie synthetische Gesundheitsbeiträge. | Verwenden Sie die Funktion **generate\$1data ()** mit einer bestimmten Eingabeaufforderung, um synthetische Gesundheitsbeiträge auf der Grundlage des bereitgestellten Schemas zu erstellen. Der Funktionsaufruf sieht wie folgt aus: health_post_data = generate_data(bedrock_rt, model_id_sonnet, system_prompt, message_healthpost, inference_config)
| Python, JSON |
| Erstellen Sie synthetische Benutzerprofile. | Verwenden Sie die Funktion **generate\$1data ()** mit einer bestimmten Meldungsaufforderung, um synthetische Benutzerprofileinträge auf der Grundlage des bereitgestellten Schemas zu erstellen. Dies ähnelt der Generierung von Gesundheitsbeiträgen, verwendet jedoch eine andere Eingabeaufforderung. | Python, JSON |
### Daten einrichten OpenSearch und aufnehmen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Richten Sie eine OpenSearch serverlose Sammlung ein. | Verwenden Sie Boto3, um eine OpenSearch serverlose Sammlung mit entsprechenden Verschlüsselungs-, Netzwerk- und Zugriffsrichtlinien zu erstellen. Die Erstellung der Sammlung sieht wie folgt aus: collection = aoss_client.create_collection(name=es_name, type='SEARCH')
Weitere Informationen zu OpenSearch Serverless finden Sie in der [AWS Dokumentation](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless.html). | OpenSearch Serverlos, IAM |
| Definieren Sie Indizes OpenSearch . | Erstellen Sie mithilfe des OpenSearch Clients Indizes für Gesundheitsposts und Benutzerprofile auf der Grundlage der vordefinierten Schemazuordnungen. Die Indexerstellung sieht wie folgt aus:response_health = oss_client.indices.create(healthpost_index, body=healthpost_body)
| OpenSearch, JSON |
| Daten laden in OpenSearch. | Führen Sie die Funktion **ingest\$1data ()** aus, um die synthetischen Gesundheitsbeiträge und Benutzerprofile massenweise in ihre jeweiligen Indizes einzufügen. OpenSearch Die Funktion verwendet den Bulk-Helper von: `opensearch-py`success, failed = bulk(oss_client, actions)
| Python, OpenSearch API, Massendatenoperationen |
### Abfragen generieren und ausführen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Entwerfen Sie einige Beispiele für Eingabeaufforderungen. | Generieren Sie Beispielabfragen und entsprechende Fragen in natürlicher Sprache, indem Sie Claude-3-Modelle verwenden, die als Beispiele für die Generierung von Abfragen dienen. Die Systemaufforderung enthält die folgenden Beispiele:system_prompt_query_generation = [{"text": f"""You are an expert query dsl generator. ... Examples: {example_prompt} ..."""}] | LLM-Aufforderung, DSL abfragen |
| Erstellen Sie einen DSL-Konverter text-to-query. | Implementieren Sie die Systemaufforderung, die Schemas, Daten und einige Beispiele enthält, für die Abfragegenerierung. Verwenden Sie die Systemaufforderung, um Abfragen in natürlicher Sprache in DSL-Abfragen zu konvertieren. Der Funktionsaufruf sieht wie folgt aus:query_response = generate_data(bedrock_rt, model_id, system_prompt_query_generation, query, inference_config)
| Python, Amazon Bedrock API, LLM-Aufforderung |
| Testen Sie die Abfrage DSL auf. OpenSearch | Führen Sie die Funktion **query\$1oss ()** aus, um die generierte DSL-Abfrage für die OpenSearch Serverless-Sammlung auszuführen und Ergebnisse zurückzugeben. Die Funktion verwendet die Suchmethode des OpenSearch Clients:response = oss_client.search(index="_all", body=temp)
| Python, OpenSearch API, DSL abfragen |
### Testen und auswerten
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie einen Testabfragesatz. | Verwenden Sie Claude 3, um einen vielfältigen Satz von Testfragen auf der Grundlage der synthetischen Daten und Schemas zu generieren:test_queries = generate_data(bedrock_rt, model_id_sonnet, query_system_prompt, query_prompt, inference_config)
| LLM-Aufforderung |
| Beurteilen Sie die Genauigkeit der DSL-Konvertierung der Abfrage. | Testen Sie die generierte DSL-Abfrage, indem Sie Abfragen ausführen OpenSearch und die zurückgegebenen Ergebnisse auf Relevanz und Genauigkeit analysieren. Dazu gehört das Ausführen der Abfrage und das Überprüfen der Treffer:output = query_oss(response1) print("Response after running query against Opensearch") print(output) | Python, Datenanalyse, Abfrage DSL |
| Benchmark Claude 3-Modelle. | Vergleichen Sie die Leistung verschiedener Claude-3-Modelle (Haiku, Sonnet, Sonnet 3.5) bei der Abfragegenerierung in Bezug auf Genauigkeit und Latenz. Ändern Sie zum Vergleich den `model_id` Zeitpunkt, zu dem Sie **generate\$1data** () aufrufen, und messen Sie die Ausführungszeit. | Python, Leistungsbenchmarking |
### Aufräumen und dokumentieren
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Entwickeln Sie einen Bereinigungsprozess. | Löschen Sie nach der Verwendung alle Indizes aus der OpenSearch Serverless-Sammlung. | Python, AWS-SDK, OpenSearch API |
## Zugehörige Ressourcen
+ [DSL abfragen](https://opensearch.org/docs/latest/query-dsl/) (OpenSearch Dokumentation)
+ [Amazon OpenSearch Service-Dokumentation](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html)
+ [OpenSearch Serverlose Sammlungen](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-manage.html)
+ [Dokumentation zu Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)
+ [Dokumentation zu Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)
+ [AWS SDK für Python (Boto3) Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Zusätzliche Informationen
**IAM-Richtlinie**
Hier ist die `APGtext2querydslpolicy` Richtlinie für die IAM-Rolle, die in diesem Muster verwendet wird:
```
{
"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": "*"
}
]
}
```
**Schnelle Techniken mit Modellen von Anthropic Claude 3**
Dieses Muster veranschaulicht die folgenden Aufforderungstechniken für die text-to-query DSL-Konvertierung unter Verwendung von Claude-3-Modellen.
+ **Few-Shot-Prompting:** Few-Shot-Prompting ist eine leistungsstarke Technik zur Verbesserung der Leistung von Claude 3-Modellen auf Amazon Bedrock. Bei diesem Ansatz wird dem Modell eine kleine Anzahl von Beispielen zur Verfügung gestellt, die das gewünschte input/output Verhalten demonstrieren, bevor es aufgefordert wird, eine ähnliche Aufgabe auszuführen. Wenn Sie Claude 3-Modelle auf Amazon Bedrock verwenden, können Few-Shot Prompting besonders effektiv für Aufgaben sein, die spezifische Formatierung, Argumentationsmuster oder Fachwissen erfordern. Um diese Technik zu implementieren, strukturieren Sie Ihre Eingabeaufforderung in der Regel mit zwei Hauptkomponenten: dem Beispielabschnitt und der eigentlichen Abfrage. Der Beispielabschnitt enthält ein oder mehrere input/output Paare, die die Aufgabe veranschaulichen, und der Abfrageabschnitt enthält die neue Eingabe, für die Sie eine Antwort wünschen. Diese Methode hilft Claude 3, den Kontext und das erwartete Ausgabeformat zu verstehen, und führt häufig zu einer genaueren und konsistenteren Antwort.
Beispiel:
```
"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.
```
+ **Systemaufforderungen:** Neben der Eingabeaufforderung mit wenigen Eingabeaufforderungen unterstützen die Claude 3-Modelle auf Amazon Bedrock auch die Verwendung von Systemaufforderungen. Systemaufforderungen sind eine Möglichkeit, dem Modell einen allgemeinen Kontext, Anweisungen oder Richtlinien zu geben, bevor es mit spezifischen Benutzereingaben versehen wird. Sie sind besonders nützlich, um den Ton anzugeben, die Rolle des Modells zu definieren oder Einschränkungen für die gesamte Konversation festzulegen. Um eine Systemaufforderung mit Claude 3 auf Amazon Bedrock zu verwenden, fügen Sie sie in den `system` Parameter Ihrer API-Anfrage ein. Dies ist unabhängig von den Benutzernachrichten und gilt für die gesamte Interaktion. Detaillierte Systemaufforderungen werden verwendet, um den Kontext festzulegen und Richtlinien für das Modell bereitzustellen.
Beispiel:
```
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.
```
+ **Strukturierte Ausgabe**: Sie können das Modell anweisen, die Ausgabe in bestimmten Formaten wie JSON oder innerhalb von XML-Tags bereitzustellen.
Beispiel:
```
Put the query in json tags
```
+ **Verkettung von Eingabeaufforderungen**: Das Notizbuch verwendet die Ausgabe eines LLM-Aufrufs als Eingabe für einen anderen, z. B. mithilfe generierter synthetischer Daten, um Beispielfragen zu erstellen.
+ **Bereitstellung von Kontext**: Der relevante Kontext, einschließlich Schemas und Beispieldaten, wird in den Eingabeaufforderungen bereitgestellt.
Beispiel:
```
Schemas: [schema details]
Data: [sample data]
```
+ **Aufgabenspezifische Eingabeaufforderungen**: Für bestimmte Aufgaben, z. B. das Generieren synthetischer Daten, das Erstellen von Beispielfragen und das Konvertieren von Abfragen in natürlicher Sprache in DSL-Abfragen, werden unterschiedliche Aufforderungen erstellt.
Beispiel für die Generierung von Testfragen:
```
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.
```
# Verwenden Sie Amazon Q Developer als Programmierassistenten, um Ihre Produktivität zu steigern
*Ram Kandaswamy, Amazon Web Services*
## Zusammenfassung
In diesem Muster wird anhand eines tic-tac-toe Spiels demonstriert, wie Sie Amazon Q Developer für eine Reihe von Entwicklungsaufgaben einsetzen können. Es generiert Code für ein tic-tac-toe Spiel als einseitige Anwendung (SPA), verbessert die Benutzeroberfläche und erstellt Skripts, auf AWS denen die Anwendung bereitgestellt wird.
Amazon Q Developer fungiert als Programmierassistent, um Arbeitsabläufe bei der Softwareentwicklung zu beschleunigen und die Produktivität sowohl für Entwickler als auch für Nicht-Entwickler zu steigern. Unabhängig von Ihrem technischen Fachwissen hilft es Ihnen dabei, Architekturen zu erstellen und Lösungen für Geschäftsprobleme zu entwerfen, Ihre Arbeitsumgebung zu optimieren, neue Funktionen zu implementieren und Testfälle zur Validierung zu generieren. Es verwendet Anweisungen in natürlicher Sprache und KI-Funktionen, um einen konsistenten, qualitativ hochwertigen Code zu gewährleisten und Programmierprobleme zu minimieren, unabhängig von Ihren Programmierkenntnissen.
Der Hauptvorteil von Amazon Q Developer ist seine Fähigkeit, Sie von sich wiederholenden Codierungsaufgaben zu befreien. Wenn Sie die `@workspace` Anmerkung verwenden, erfasst und indexiert Amazon Q Developer alle Codedateien, Konfigurationen und Projektstrukturen in Ihrer integrierten Entwicklungsumgebung (IDE) und bietet maßgeschneiderte Antworten, damit Sie sich auf die kreative Problemlösung konzentrieren können. Sie können mehr Zeit für die Entwicklung innovativer Lösungen und die Verbesserung der Benutzererfahrung aufwenden. Wenn Sie nicht technisch versiert sind, können Sie Amazon Q Developer verwenden, um Arbeitsabläufe zu optimieren und effektiver mit dem Entwicklungsteam zusammenzuarbeiten. Die Amazon Q Developer **Explain Code-Funktion** bietet detaillierte Anweisungen und Zusammenfassungen, sodass Sie sich in komplexen Codebasen zurechtfinden.
Darüber hinaus bietet Amazon Q Developer einen sprachunabhängigen Ansatz, der jüngeren und mittleren Entwicklern hilft, ihre Fähigkeiten zu erweitern. Sie können sich auf Kernkonzepte und Geschäftslogik statt auf die sprachspezifische Syntax konzentrieren. Dies reduziert die Lernkurve, wenn Sie die Technologie wechseln.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ IDE (zum Beispiel WebStorm oder Visual Studio Code) mit installiertem Amazon Q Developer-Plugin. Anweisungen finden Sie unter [Installation der Amazon Q Developer-Erweiterung oder des Amazon Q Developer-Plugins in Ihrer IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html) in der Amazon Q Developer-Dokumentation.
+ Eine aktive AWS-Konto Einrichtung mit Amazon Q Developer. Anweisungen finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/getting-started-q-dev.html) in der Amazon Q Developer-Dokumentation.
+ **npm** ist installiert. Anweisungen finden Sie in der [npm-Dokumentation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm). Dieses Muster wurde mit npm Version 10.8 getestet.
+ AWS Command Line Interface (AWS CLI) installiert. Anweisungen finden Sie in der [AWS CLI Dokumentation](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Einschränkungen**
+ Amazon Q Developer kann jeweils nur eine Entwicklungsaufgabe ausführen.
+ Einige AWS-Services sind nicht in allen verfügbar AWS-Regionen. Informationen zur Verfügbarkeit in den einzelnen Regionen finden Sie [AWS-Services unter Nach Regionen](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Informationen zu bestimmten Endpunkten finden Sie auf der Seite [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html). Wählen Sie dort den Link für den Dienst aus.
## Tools
+ Für dieses Muster ist eine IDE wie Visual Studio Code oder erforderlich. WebStorm Eine Liste der unterstützten IDEs Produkte finden Sie in der [Amazon Q Developer-Dokumentation](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) ist ein Open-Source-Tool, mit dem Sie AWS-Services über Befehle in Ihrer Befehlszeilen-Shell interagieren können.
## Best Practices
Weitere Informationen finden Sie unter [Bewährte Programmierpraktiken mit Amazon Q Developer](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/best-practices-coding.html) in AWS Prescriptive Guidance. Darüber hinaus:
+ Wenn Sie Amazon Q Developer auffordern, stellen Sie sicher, dass Ihre Anweisungen klar und eindeutig sind. Fügen Sie der Aufforderung Codefragmente und Anmerkungen hinzu, `@workspace` um mehr Kontext für Ihre Eingabeaufforderungen bereitzustellen.
+ Fügen Sie relevante Bibliotheken hinzu und importieren Sie sie, um Konflikte oder falsche Vermutungen durch das System zu vermeiden.
+ Wenn der generierte Code nicht korrekt oder erwartungsgemäß ist, verwenden Sie die Option **Feedback geben und neu generieren**. Versuchen Sie, die Eingabeaufforderungen in kleinere Anweisungen aufzuteilen.
## Epen
### Richten Sie die Arbeitsumgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellt ein neues Projekt. | Um ein neues Projekt in Ihrer Arbeitsumgebung zu erstellen, führen Sie den folgenden Befehl aus und akzeptieren Sie die Standardeinstellungen für alle Fragen:npx create-next-app@latest
| App-Entwickler, Programmierer, Softwareentwickler |
| Testen Sie die Basisanwendung. | Führen Sie den folgenden Befehl aus und vergewissern Sie sich, dass die Basisanwendung erfolgreich im Browser geladen wurde:npm run dev
| App-Entwickler, Programmierer, Softwareentwickler |
| Bereinigen Sie den Basiscode. | Navigieren Sie zu der `page.tsx` Datei im `src/app` Ordner und löschen Sie den Standardinhalt, um eine leere Seite zu erhalten. Nach dem Löschen sollte die Datei wie folgt aussehen:export default function Home() {
return (
);
} | App-Entwickler, Programmierer, Softwareentwickler |
### Verwenden Sie Amazon Q Developer, um ein tic-tac-toe Spieleprojekt zu entwerfen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Verschaffen Sie sich einen Überblick über die Schritte. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | App-Entwickler, Programmierer, Softwareentwickler |
| Code generieren für tic-tac-toe. | Starten Sie im Chat-Panel eine Entwicklungsaufgabe, indem Sie den `/dev` Befehl gefolgt von der Beschreibung der Aufgabe verwenden. Beispiel:/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.
Amazon Q Developer generiert Code auf der Grundlage Ihrer Anweisungen. | App-Entwickler, Programmierer, Softwareentwickler |
| Untersuchen und akzeptieren Sie den generierten Code. | Untersuchen Sie den Code visuell und wählen Sie **Code akzeptieren**, um die `page.tsx` Datei automatisch zu ersetzen.Wenn Sie auf Probleme stoßen, wählen Sie **Feedback geben und erneut generieren** und beschreiben Sie das aufgetretene Problem. | App-Entwickler, Programmierer, Softwareentwickler |
| Korrigieren Sie Lint-Fehler. | Das tic-tac-toe Beispielspiel enthält ein Raster. Der Code, den Amazon Q Developer generiert, verwendet möglicherweise den Standardtyp`any`. Sie können Typsicherheit hinzufügen, indem Sie Amazon Q Developer wie folgt auffordern:/dev Ensure proper TypeScript typing for the onSquare Click event handler
to resolve any 'any' type issues.
| App-Entwickler, Programmierer, Softwareentwickler |
| Fügen Sie visuellen Reiz hinzu. | Sie können die ursprüngliche Anforderung in kleinere Fragmente aufteilen. Beispielsweise kannst du die Benutzeroberfläche des Spiels mit den folgenden Eingabeaufforderungen in den Entwickleraufgaben verbessern. Diese Aufforderung verbessert die CSS-Stile (Cascading Style Sheets) und exportiert die App zur Bereitstellung./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.
| App-Entwickler, Programmierer, Softwareentwickler |
| Testen Sie erneut. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | App-Entwickler, Programmierer, Softwareentwickler |
### Stellen Sie die Anwendung auf dem bereit AWS Cloud
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Erstellen Sie Ordner und Dateien für die Bereitstellung. | Erstellen Sie im Projekt in Ihrer Arbeitsumgebung einen Bereitstellungsordner und zwei darin enthaltene Dateien: `pushtos3.sh` und`cloudformation.yml`:mkdir deployment && cd deployment
touch pushtos3.sh && chmod +x pushtos3.sh
touch cloudformation.yml
| App-Entwickler, Programmierer, Softwareentwickler |
| Generieren Sie Automatisierungscode. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | AWS-Administrator, AWS DevOps, App-Entwickler |
| Generieren Sie Skriptinhalte. | Verwenden Sie die folgende Eingabeaufforderung, um ein Bereitstellungsskript zu erstellen:/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.
| App-Entwickler, Programmierer, Softwareentwickler |
| Stellen Sie die Anwendung auf dem AWS Cloud bereit. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | AWS-Administrator DevOps, AWS, Cloud-Architekt, App-Entwickler |
## Fehlerbehebung
| Problem | Lösung |
| --- | --- |
| Der Build erstellt keine einseitige Anwendung und exportiert sie auch nicht in den Ausgabeordner. | Sehen Sie sich den Inhalt der `next.config.mjs` Datei an.Wenn der Code die folgende Standardkonfiguration hat:const nextConfig = {};ändere ihn wie folgt:const nextConfig = {
output: 'export',
distDir: 'out',
}; |
## Zugehörige Ressourcen
+ [Ein neues React-Projekt erstellen](https://react.dev/learn/start-a-new-react-project) (React-Dokumentation)
+ [Überblick über Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) (AWS Dokumentation)
+ [Bewährte Methoden für Amazon Q Developer](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/introduction.html) (AWS Prescriptive Guidance)
+ [Installation, Konfiguration und Verwendung von Amazon Q Developer mit JetBrains IDEs](https://www.youtube.com/watch?v=-iQfIhTA4J0&pp=ygUSYW1hem9uIHEgZGV2ZWxvcGVy) (YouTube Video)
+ [Installation von Amazon Q für die Befehlszeile](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-getting-started-installing.html) (AWS Dokumentation)
# Verwenden Sie SageMaker Processing für verteiltes Feature-Engineering von ML-Datensätzen im Terabyte-Bereich
*Chris Boomhower, Amazon Web Services*
## Zusammenfassung
Viele Datensätze im Terabyte-Bereich oder größer bestehen oft aus einer hierarchischen Ordnerstruktur, und die Dateien im Datensatz weisen manchmal wechselseitige Abhängigkeiten auf. Aus diesem Grund müssen Ingenieure und Datenwissenschaftler für maschinelles Lernen (ML) durchdachte Designentscheidungen treffen, um solche Daten für Modelltraining und Inferenz aufzubereiten. Dieses Muster zeigt, wie Sie manuelle Macrosharding- und Microsharding-Techniken in Kombination mit Amazon SageMaker Processing und virtueller CPU (vCPU) -Parallelisierung verwenden können, um Feature-Engineering-Prozesse für komplizierte Big-Data-ML-Datensätze effizient zu skalieren.
Dieses Muster definiert *Macrosharding* als die Aufteilung von Datenverzeichnissen auf mehrere Computer zur Verarbeitung und *Microsharding* als die Aufteilung von Daten auf jedem Computer über mehrere Verarbeitungsthreads. [Das Muster demonstriert diese Techniken, indem Amazon SageMaker mit Beispiel-Zeitreihen-Wellenformaufzeichnungen aus dem MIMIC-III-Datensatz verwendet wirdPhysioNet .](https://physionet.org/content/mimic3wdb/1.0/) Durch die Implementierung der Techniken in diesem Muster können Sie die Verarbeitungszeit und die Kosten für das Feature-Engineering minimieren und gleichzeitig die Ressourcennutzung und Durchsatzeffizienz maximieren. Diese Optimierungen basieren auf verteilter SageMaker Verarbeitung auf Amazon Elastic Compute Cloud (Amazon EC2) -Instances und v CPUs für ähnliche, große Datensätze, unabhängig vom Datentyp.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Zugriff auf SageMaker Notebook-Instances oder SageMaker Studio, wenn Sie dieses Muster für Ihren eigenen Datensatz implementieren möchten. Wenn Sie Amazon SageMaker zum ersten Mal verwenden, finden Sie weitere Informationen unter [Erste Schritte mit Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html) in der AWS-Dokumentation.
+ SageMaker Studio, wenn Sie dieses Muster mit den [PhysioNet MIMIC-III-Beispieldaten](https://physionet.org/content/mimic3wdb/1.0/) implementieren möchten.
+ Das Muster verwendet SageMaker Processing, erfordert jedoch keine Erfahrung mit der Ausführung von SageMaker Processing-Jobs.
**Einschränkungen**
+ Dieses Muster eignet sich gut für ML-Datensätze, die voneinander abhängige Dateien enthalten. Diese Interdependenzen profitieren am meisten von manuellem Macrosharding und der parallel Ausführung mehrerer SageMaker Einzelinstanz-Verarbeitungsjobs. Für Datensätze, bei denen solche Interdependenzen nicht existieren, ist die `ShardedByS3Key` Funktion in SageMaker Processing möglicherweise eine bessere Alternative zum Macrosharding, da sie fragmentierte Daten an mehrere Instanzen sendet, die von demselben Verarbeitungsauftrag verwaltet werden. Sie können jedoch die Microsharding-Strategie dieses Musters in beiden Szenarien implementieren, um Instanz v optimal zu nutzen. CPUs
**Produktversionen**
+ Amazon SageMaker Python SDK, Version 2
## Architektur
**Zieltechnologie-Stack**
+ Amazon Simple Storage Service (Amazon-S3)
+ Amazon SageMaker
**Zielarchitektur**
*Macrosharding und verteilte Instanzen EC2 *
Die 10 parallel Prozesse, die in dieser Architektur dargestellt werden, spiegeln die Struktur des MIMIC-III-Datensatzes wider. (Prozesse werden zur Vereinfachung des Diagramms durch Ellipsen dargestellt.) Eine ähnliche Architektur gilt für jeden Datensatz, wenn Sie manuelles Macrosharding verwenden. Im Fall von MIMIC-III können Sie die Rohstruktur des Datensatzes zu Ihrem Vorteil nutzen, indem Sie jeden Patientengruppenordner mit minimalem Aufwand separat verarbeiten. In der folgenden Abbildung wird der Block Datensatzgruppen auf der linken Seite angezeigt (1). Da die Daten verteilt sind, ist es sinnvoll, sie nach Patientengruppen aufzuteilen.
![\[Architektur für Microsharding und verteilte Instanzen EC2\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/images/c19a8f87-ac59-458e-89cb-50be17ca4a0c.png)
Manuelles Sharding nach Patientengruppen bedeutet jedoch, dass für jeden Patientengruppenordner ein separater Verarbeitungsauftrag erforderlich ist, wie Sie im mittleren Abschnitt des Diagramms (2) sehen können, und nicht ein einziger Verarbeitungsauftrag mit mehreren Instanzen. EC2 Da die Daten von MIMIC-III sowohl binäre Wellenformdateien als auch passende textbasierte Header-Dateien enthalten und für die binäre Datenextraktion eine Abhängigkeit von der [WFDB-Bibliothek](https://wfdb.readthedocs.io/en/latest/) erforderlich ist, müssen alle Datensätze für einen bestimmten Patienten auf derselben Instanz verfügbar gemacht werden. Die einzige Möglichkeit, sicherzustellen, dass die jeder binären Wellenformdatei zugeordnete Header-Datei auch vorhanden ist, besteht darin, manuelles Sharding zu implementieren, um jeden Shard innerhalb seines eigenen Verarbeitungsjobs auszuführen und anzugeben, `s3_data_distribution_type='FullyReplicated'` wann Sie die Eingabe für den Verarbeitungsjob definieren. Wenn alle Daten in einem einzigen Verzeichnis verfügbar wären und es keine Abhängigkeiten zwischen den Dateien gäbe, könnte es alternativ besser sein, einen einzelnen Verarbeitungsauftrag mit mehreren EC2 Instanzen zu starten und anzugeben. `s3_data_distribution_type='ShardedByS3Key'` Wenn Sie `ShardedByS3Key ` als Amazon S3 S3-Datenverteilungstyp angeben, wird SageMaker das Daten-Sharding automatisch über Instances hinweg verwaltet.
Das Starten eines Verarbeitungsauftrags für jeden Ordner ist eine kostengünstige Methode zur Vorverarbeitung der Daten, da die gleichzeitige Ausführung mehrerer Instances Zeit spart. Um zusätzliche Kosten und Zeit zu sparen, können Sie Microsharding für jeden Verarbeitungsauftrag verwenden.
*Microsharding und paralleles V CPUs*
Innerhalb jedes Verarbeitungsauftrags werden die gruppierten Daten weiter aufgeteilt, um die Nutzung aller verfügbaren V CPUs auf der SageMaker vollständig verwalteten EC2 Instanz zu maximieren. Die Blöcke im mittleren Abschnitt des Diagramms (2) zeigen, was innerhalb der einzelnen primären Verarbeitungsaufträge passiert. Der Inhalt der Patientenaktenordner wird vereinfacht und gleichmäßig auf der Grundlage der Anzahl der verfügbaren V CPUs auf der Instanz aufgeteilt. Nachdem der Ordnerinhalt aufgeteilt wurde, wird der Satz von Dateien mit gleichmäßiger Größe CPUs zur Verarbeitung auf alle V verteilt. Wenn die Verarbeitung abgeschlossen ist, werden die Ergebnisse jeder vCPU in einer einzigen Datendatei für jeden Verarbeitungsauftrag zusammengefasst.
Im beigefügten Code werden diese Konzepte im folgenden Abschnitt der `src/feature-engineering-pass1/preprocessing.py` Datei dargestellt.
```
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))
```
Eine Funktion,`chunks`, wird zunächst so definiert, dass sie eine bestimmte Liste verarbeitet, indem sie sie in gleich große Längenabschnitte aufteilt `n ` und diese Ergebnisse als Generator zurückgibt. Als Nächstes werden die Daten auf alle Patientenordner reduziert, indem eine Liste aller vorhandenen binären Wellenformdateien erstellt wird. Danach wird die Anzahl von v ermittelt, die auf der Instanz CPUs verfügbar ist. EC2 [Die Liste der binären Wellenformdateien wird CPUs durch Aufruf gleichmäßig auf diese v aufgeteilt`chunks`, und dann wird jede Wellenform-Unterliste auf ihrer eigenen vCPU verarbeitet, indem die Parallel-Klasse von joblib verwendet wird.](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html) Die Ergebnisse werden vom Verarbeitungsauftrag automatisch zu einer einzigen Liste von Datenrahmen kombiniert, der SageMaker dann weiter verarbeitet wird, bevor er nach Abschluss des Auftrags in Amazon S3 geschrieben wird. In diesem Beispiel werden von den Verarbeitungsaufträgen 10 Dateien in Amazon S3 geschrieben (eine für jeden Job).
Wenn alle anfänglichen Verarbeitungsaufträge abgeschlossen sind, kombiniert ein sekundärer Verarbeitungsauftrag, der im Block rechts neben dem Diagramm (3) dargestellt ist, die von jedem primären Verarbeitungsauftrag erstellten Ausgabedateien und schreibt die kombinierte Ausgabe in Amazon S3 (4).
## Tools
**Tools**
+ [Python](https://www.python.org/) — Der für dieses Muster verwendete Beispielcode ist Python (Version 3).
+ [SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) — Amazon SageMaker Studio ist eine webbasierte, integrierte Entwicklungsumgebung (IDE) für maschinelles Lernen, mit der Sie Ihre Machine-Learning-Modelle erstellen, trainieren, debuggen, bereitstellen und überwachen können. Sie führen SageMaker Verarbeitungsaufträge mithilfe von Jupyter-Notebooks in Studio aus. SageMaker
+ [SageMaker Verarbeitung](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) — Amazon SageMaker Processing bietet eine vereinfachte Möglichkeit, Ihre Datenverarbeitungs-Workloads auszuführen. In diesem Muster wird der Feature-Engineering-Code mithilfe von SageMaker Verarbeitungsaufträgen maßstabsgetreu implementiert.
**Code**
Die angehängte ZIP-Datei enthält den vollständigen Code für dieses Muster. Im folgenden Abschnitt werden die Schritte zum Erstellen der Architektur für dieses Muster beschrieben. Jeder Schritt wird durch einen Beispielcode aus dem Anhang veranschaulicht.
## Epen
### Richten Sie Ihre SageMaker Studio-Umgebung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Greifen Sie auf Amazon SageMaker Studio zu. | Starten Sie SageMaker Studio über Ihr AWS-Konto, indem Sie den Anweisungen in der [ SageMaker Amazon-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) folgen. | Datenwissenschaftler, ML-Ingenieur |
| Installieren Sie das Hilfsprogramm wget. | Installieren Sie *wget*, wenn Sie mit einer neuen SageMaker Studio-Konfiguration vertraut sind oder wenn Sie diese Dienstprogramme noch nie in Studio verwendet haben. SageMaker Öffnen Sie zur Installation ein Terminalfenster in der SageMaker Studio-Konsole und führen Sie den folgenden Befehl aus:sudo yum install wget
| Datenwissenschaftler, ML-Ingenieur |
| Laden Sie den Beispielcode herunter und entpacken Sie ihn. | Laden Sie die `attachments.zip` Datei im Bereich *Anlagen* herunter. Navigieren Sie in einem Terminalfenster zu dem Ordner, in den Sie die Datei heruntergeladen haben, und extrahieren Sie ihren Inhalt:unzip attachment.zip
Navigieren Sie zu dem Ordner, in den Sie die ZIP-Datei extrahiert haben, und extrahieren Sie den Inhalt der `Scaled-Processing.zip` Datei.unzip Scaled-Processing.zip
| Datenwissenschaftler, ML-Ingenieur |
| Laden Sie den Beispieldatensatz von physionet.org herunter und laden Sie ihn auf Amazon S3 hoch. | Führen Sie das `get_data.ipynb` Jupyter-Notizbuch in dem Ordner aus, der die Dateien enthält. `Scaled-Processing` Dieses Notizbuch lädt einen MIMIC-III-Beispieldatensatz von [physionet.org](https://physionet.org) herunter und lädt ihn in Ihren SageMaker Studio-Sitzungs-Bucket in Amazon S3 hoch. | Datenwissenschaftler, ML-Ingenieur |
### Konfigurieren Sie das erste Vorverarbeitungsskript
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Reduzieren Sie die Dateihierarchie in allen Unterverzeichnissen. | In großen Datensätzen wie MIMIC-III sind Dateien häufig auf mehrere Unterverzeichnisse verteilt, selbst innerhalb einer logischen übergeordneten Gruppe. Ihr Skript sollte so konfiguriert sein, dass alle Gruppendateien in allen Unterverzeichnissen reduziert werden, wie der folgende Code zeigt.# 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']
Die Beispielcodefragmente in diesem Epos stammen aus der `src/feature-engineering-pass1/preprocessing.py` Datei, die im Anhang enthalten ist. | Datenwissenschaftler, ML-Ingenieur |
| Teilen Sie Dateien basierend auf der Anzahl der vCPU in Untergruppen auf. | Dateien sollten in gleichmäßig große Untergruppen oder Blöcke aufgeteilt werden, abhängig von der Anzahl der V, die auf der Instanz CPUs vorhanden sind, die das Skript ausführt. Für diesen Schritt können Sie Code implementieren, der dem folgenden ähnelt.# 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))
| Datenwissenschaftler, ML-Ingenieur |
| Parallelisieren Sie die Verarbeitung von Untergruppen über v. CPUs | Die Skriptlogik sollte so konfiguriert sein, dass alle Untergruppen parallel verarbeitet werden. Verwenden Sie dazu die `Parallel ` Klasse und `delayed ` Methode der Joblib-Bibliothek wie folgt. # 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)
| Datenwissenschaftler, ML-Ingenieur |
| Speichern Sie die Ausgabe einer einzelnen Dateigruppe in Amazon S3. | Wenn die parallel vCPU-Verarbeitung abgeschlossen ist, sollten die Ergebnisse jeder vCPU kombiniert und in den S3-Bucket-Pfad der Dateigruppe hochgeladen werden. Für diesen Schritt können Sie Code verwenden, der dem folgenden ähnelt.# 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))
| Datenwissenschaftler, ML-Ingenieur |
### Konfigurieren Sie das zweite Vorverarbeitungsskript
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Kombinieren Sie Datendateien, die bei allen Verarbeitungsaufträgen erstellt wurden, bei denen das erste Skript ausgeführt wurde. | Das vorherige Skript gibt für jeden SageMaker Verarbeitungsjob, der eine Gruppe von Dateien aus dem Datensatz verarbeitet, eine einzelne Datei aus. Als Nächstes müssen Sie diese Ausgabedateien zu einem einzigen Objekt kombinieren und einen einzigen Ausgabedatensatz in Amazon S3 schreiben. Dies wird in der `src/feature-engineering-pass1p5/preprocessing.py` Datei, die im Anhang bereitgestellt wird, wie folgt demonstriert.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()
| Datenwissenschaftler, ML-Ingenieur |
### Verarbeitungsaufträge ausführen
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Führen Sie den ersten Verarbeitungsauftrag aus. | Um Macrosharding durchzuführen, führen Sie für jede Dateigruppe einen separaten Verarbeitungsauftrag aus. Microsharding wird innerhalb jedes Verarbeitungsauftrags ausgeführt, da jeder Job Ihr erstes Skript ausführt. Der folgende Code zeigt, wie ein Verarbeitungsauftrag für jedes Dateigruppenverzeichnis im folgenden Codeausschnitt (enthalten in) gestartet wird. `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
)
| Datenwissenschaftler, ML-Ingenieur |
| Führen Sie den zweiten Verarbeitungsauftrag aus. | Um die vom ersten Satz von Verarbeitungsaufträgen generierten Ausgaben zu kombinieren und zusätzliche Berechnungen für die Vorverarbeitung durchzuführen, führen Sie Ihr zweites Skript mit einem einzigen SageMaker Verarbeitungsauftrag aus. Der folgende Code veranschaulicht dies (enthalten in`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
)
| Datenwissenschaftler, ML-Ingenieur |
## Zugehörige Ressourcen
+ [Mit Quick Start in Amazon SageMaker Studio einsteigen](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) (SageMaker Dokumentation)
+ [Daten verarbeiten](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) (SageMaker Dokumentation)
+ [Datenverarbeitung mit Scikit-Learn](https://docs.aws.amazon.com/sagemaker/latest/dg/use-scikit-learn-processing-container.html) (Dokumentation) SageMaker
+ [JobLib.Parallel-Dokumentation](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html)
+ Moody, B., Moody, G., Villarroel, M., Clifford, G.D., & Silva, I. (2020). [MIMIC-III-Wellenform-Datenbank](https://doi.org/10.13026/c2607m) (Version 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., & Mark, R.G. (2016). [MIMIC-III](https://dx.doi.org/10.1038/sdata.2016.35), eine frei zugängliche Datenbank für Intensivpflege. Wissenschaftliche Daten, 3, 160035.
+ [MIMIC-III Waveform Database-Lizenz](https://physionet.org/content/mimic3wdb/1.0/LICENSE.txt)
## Anlagen
[Um auf zusätzliche Inhalte zuzugreifen, die mit diesem Dokument verknüpft sind, entpacken Sie die folgende Datei: attachment.zip](samples/p-attach/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/attachments/attachment.zip)
# Visualisieren Sie AI/ML Modellergebnisse mit Flask und AWS Elastic Beanstalk
*Chris Caudill und Durga Sury, Amazon Web Services*
## Zusammenfassung
Die Visualisierung der Ergebnisse von Diensten für künstliche Intelligenz und maschinelles Lernen (KI/ML) erfordert häufig komplexe API-Aufrufe, die von Ihren Entwicklern und Technikern angepasst werden müssen. Dies kann ein Nachteil sein, wenn Ihre Analysten schnell einen neuen Datensatz untersuchen möchten.
Sie können die Zugänglichkeit Ihrer Dienste verbessern und eine interaktivere Form der Datenanalyse bereitstellen, indem Sie eine webbasierte Benutzeroberfläche (UI) verwenden, über die Benutzer ihre eigenen Daten hochladen und die Modellergebnisse in einem Dashboard visualisieren können.
Dieses Muster verwendet [Flask](https://flask.palletsprojects.com/en/2.0.x/) und [Plotly](https://plotly.com/), um Amazon Comprehend in eine benutzerdefinierte Webanwendung zu integrieren und Stimmungen und Entitäten anhand von Benutzerdaten zu visualisieren. Das Muster enthält auch die Schritte zur Bereitstellung einer Anwendung mithilfe von AWS Elastic Beanstalk. Sie können die Anwendung mithilfe der [KI-Services von Amazon Web Services (AWS)](https://aws.amazon.com/machine-learning/ai-services/) oder mithilfe eines speziell trainierten Modells anpassen, das auf einem Endpunkt (z. B. einem [ SageMaker Amazon-Endpunkt](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html)) gehostet wird.
## Voraussetzungen und Einschränkungen
**Voraussetzungen**
+ Ein aktives AWS-Konto.
+ AWS-Befehlszeilenschnittstelle (AWS CLI), auf Ihrem lokalen Computer installiert und konfiguriert. Weitere Informationen dazu finden Sie unter [Grundlagen der Konfiguration](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) in der AWS-CLI-Dokumentation. Sie können auch eine integrierte Entwicklungsumgebung (IDE) von AWS Cloud9 verwenden. Weitere Informationen dazu finden Sie im [Python-Tutorial für AWS Cloud9 und unter Vorschau laufender Anwendungen in der AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/sample-python.html) [Cloud9-IDE in der AWS Cloud9 Cloud9-Dokumentation](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html).
**Hinweis**: AWS Cloud9 ist für Neukunden nicht mehr verfügbar. Bestandskunden von AWS Cloud9 können den Service weiterhin wie gewohnt nutzen. [Weitere Informationen](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
+ Ein Verständnis des Webanwendungs-Frameworks von Flask. Weitere Informationen zu Flask finden Sie im [Schnellstart](https://flask.palletsprojects.com/en/1.1.x/quickstart) in der Flask-Dokumentation.
+ Python Version 3.6 oder höher, installiert und konfiguriert. Sie können Python installieren, indem Sie den Anweisungen unter [Einrichten Ihrer Python-Entwicklungsumgebung](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html) in der Dokumentation zu AWS Elastic Beanstalk folgen.
+ Elastic Beanstalk Command Line Interface (EB CLI), installiert und konfiguriert. Weitere Informationen dazu finden Sie in [der Dokumentation zu AWS Elastic Beanstalk unter Installieren der EB-CLI](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-install.html) [und Konfigurieren](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-configuration.html) der EB-CLI.
**Einschränkungen**
+ Die Flask-Anwendung dieses Musters wurde für die Arbeit mit CSV-Dateien entwickelt, die eine einzige Textspalte verwenden und auf 200 Zeilen beschränkt sind. Der Anwendungscode kann an andere Dateitypen und Datenmengen angepasst werden.
+ Die Anwendung berücksichtigt keine Datenspeicherung und aggregiert weiterhin hochgeladene Benutzerdateien, bis sie manuell gelöscht werden. Sie können die Anwendung in Amazon Simple Storage Service (Amazon S3) für persistenten Objektspeicher integrieren oder eine Datenbank wie Amazon DynamoDB für die serverlose Speicherung von Schlüsselwerten verwenden.
+ Die Anwendung berücksichtigt nur Dokumente in englischer Sprache. Sie können Amazon Comprehend jedoch verwenden, um die Hauptsprache eines Dokuments zu ermitteln. Weitere Informationen zu den unterstützten Sprachen für jede Aktion finden Sie in der [API-Referenz](https://docs.aws.amazon.com/comprehend/latest/dg/API_Reference.html) in der Amazon Comprehend Comprehend-Dokumentation.
+ Eine Liste zur Fehlerbehebung, die häufig auftretende Fehler und deren Lösungen enthält, finden Sie im Abschnitt *Zusätzliche Informationen*.
## Architektur
**Die Architektur der Flask-Anwendung**
Flask ist ein leichtes Framework für die Entwicklung von Webanwendungen in Python. Es wurde entwickelt, um die leistungsstarke Datenverarbeitung von Python mit einer umfangreichen Weboberfläche zu kombinieren. Die Flask-Anwendung des Musters zeigt Ihnen, wie Sie eine Webanwendung erstellen, mit der Benutzer Daten hochladen, die Daten zur Inferenz an Amazon Comprehend senden und dann die Ergebnisse visualisieren können. Die Anwendung hat die folgende Struktur:
+ `static`— Enthält alle statischen Dateien, die die Weboberfläche unterstützen (z. JavaScript B. CSS und Bilder)
+ `templates`— Enthält alle HTML-Seiten der Anwendung
+ `userData`— Speichert hochgeladene Benutzerdaten
+ `application.py`— Die Flask-Anwendungsdatei
+ `comprehend_helper.py`— Funktionen für API-Aufrufe an Amazon Comprehend
+ `config.py`— Die Konfigurationsdatei der Anwendung
+ `requirements.txt`— Die von der Anwendung benötigten Python-Abhängigkeiten
Das `application.py` Skript enthält die Kernfunktionalität der Webanwendung, die aus vier Flask-Routen besteht. Das folgende Diagramm zeigt diese Flask-Routen.
![\[Die vier Flask-Routen, die die Kernfunktionalität der Webanwendung ausmachen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/9ca6bad1-26e2-4262-98d0-d54c172336bf.png)
+ `/`ist das Stammverzeichnis der Anwendung und leitet Benutzer auf die `upload.html` Seite weiter (die im `templates` Verzeichnis gespeichert ist).
+ `/saveFile`ist eine Route, die aufgerufen wird, nachdem ein Benutzer eine Datei hochgeladen hat. Diese Route empfängt eine `POST` Anfrage über ein HTML-Formular, das die vom Benutzer hochgeladene Datei enthält. Die Datei wird im `userData` Verzeichnis gespeichert und die Route leitet Benutzer zur `/dashboard` Route weiter.
+ `/dashboard`sendet Benutzer auf die `dashboard.html` Seite. Im HTML-Code dieser Seite wird der JavaScript Code ausgeführt, der `static/js/core.js` Daten aus der `/data` Route liest und dann Visualisierungen für die Seite erstellt.
+ `/data`ist eine JSON-API, die die zu visualisierenden Daten im Dashboard präsentiert. Diese Route liest die vom Benutzer bereitgestellten Daten und verwendet die Funktionen, um die Benutzerdaten `comprehend_helper.py` zur Stimmungsanalyse und Named Entity Recognition (NER) an Amazon Comprehend zu senden. Die Antwort von Amazon Comprehend wird formatiert und als JSON-Objekt zurückgegeben.
**Architektur der Bereitstellung**
![\[Architekturdiagramm für die Verwendung von Flask und Elastic Beanstalk zur Visualisierung AI/ML von Modellergebnissen.\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/d691bfd2-e2ec-4830-8bff-ffa1e3a95c4a.png)
[Überlegungen zum Entwurf](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.concepts.design.html)
Weitere Informationen zu Designüberlegungen für Anwendungen, die mit Elastic Beanstalk in der AWS-Cloud bereitgestellt werden, finden Sie in der Dokumentation zu AWS Elastic Beanstalk.
**Technologie-Stack**
+ Amazon Comprehend
+ Elastic Beanstalk
+ Flask
**Automatisierung und Skalierung**
Elastic Beanstalk Beanstalk-Bereitstellungen werden automatisch mit Load Balancern und Auto Scaling-Gruppen eingerichtet. Weitere Konfigurationsoptionen finden Sie unter [Konfiguration von Elastic Beanstalk-Umgebungen in der Dokumentation zu AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html).
## Tools
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein einheitliches Tool, das eine konsistente Schnittstelle für die Interaktion mit allen Teilen von AWS bietet.
+ [Amazon Comprehend](https://docs.aws.amazon.com/comprehend/latest/dg/comprehend-general.html) verwendet Natural Language Processing (NLP), um Erkenntnisse über den Inhalt von Dokumenten zu gewinnen, ohne dass eine spezielle Vorverarbeitung erforderlich ist.
+ Mit [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html) können Sie Anwendungen in der AWS-Cloud schnell bereitstellen und verwalten, ohne sich mit der Infrastruktur vertraut machen zu müssen, auf der diese Anwendungen ausgeführt werden.
+ [Elastic Beanstalk CLI (EB CLI)](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3.html) ist eine Befehlszeilenschnittstelle für AWS Elastic Beanstalk, die interaktive Befehle bereitstellt, um die Erstellung, Aktualisierung und Überwachung von Umgebungen aus einem lokalen Repository zu vereinfachen.
+ Das [Flask-Framework](https://flask.palletsprojects.com/en/2.0.x/) führt Datenverarbeitung und API-Aufrufe mit Python durch und bietet interaktive Webvisualisierung mit Plotly.
**Code**
Der Code für dieses Muster ist im Repository GitHub [Visualize AI/ML model results using Flask and AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) verfügbar.
## Epen
### Richten Sie die Flask-Anwendung ein
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Klonen Sie das GitHub Repository. | Rufen Sie den Anwendungscode aus dem GitHub [Visualize AI/ML Model Results using Flask and AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) Repository ab, indem Sie den folgenden Befehl ausführen:`git clone git@github.com:aws-samples/aws-comprehend-elasticbeanstalk-for-flask.git`Stellen Sie sicher, dass Sie Ihre SSH-Schlüssel mit konfigurieren. GitHub | Developer |
| Installieren Sie die Python-Module. | Nachdem Sie das Repository geklont haben, wird ein neues lokales `aws-comprehend-elasticbeanstalk-for-flask` Verzeichnis erstellt. In diesem Verzeichnis enthält die `requirements.txt` Datei die Python-Module und -Versionen, die die Anwendung ausführen. Verwenden Sie die folgenden Befehle, um die Module zu installieren:`cd aws-comprehend-elasticbeanstalk-for-flask``pip install -r requirements.txt` | Python-Entwickler |
| Testen Sie die Anwendung lokal. | Starten Sie den Flask-Server, indem Sie den folgenden Befehl ausführen:`python application.py`Dies gibt Informationen über den laufenden Server zurück. Sie sollten auf die Anwendung zugreifen können, indem Sie einen Browser öffnen und http://localhost:5000 aufrufenWenn Sie die Anwendung in einer AWS Cloud9 Cloud9-IDE ausführen, müssen Sie den `application.run()` Befehl in der `application.py` Datei durch die folgende Zeile ersetzen:`application.run(host=os.getenv('IP', '0.0.0.0'),port=int(os.getenv('PORT', 8080)))`Sie müssen diese Änderung vor der Bereitstellung rückgängig machen. | Python-Entwickler |
### Stellen Sie die Anwendung auf Elastic Beanstalk bereit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Starten Sie die Elastic Beanstalk Beanstalk-Anwendung. | Um Ihr Projekt als Elastic Beanstalk Beanstalk-Anwendung zu starten, führen Sie den folgenden Befehl im Stammverzeichnis Ihrer Anwendung aus:`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/de_de/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html)Führen Sie den `eb init -i` Befehl aus, um weitere Konfigurationsoptionen für die Bereitstellung zu erhalten. | Architekt, Entwickler |
| Stellen Sie die Elastic Beanstalk Beanstalk-Umgebung bereit. | Führen Sie den folgenden Befehl im Stammverzeichnis der Anwendung aus:`eb create comprehend-flask-env``comprehend-flask-env`ist der Name der Elastic Beanstalk Beanstalk-Umgebung und kann entsprechend Ihren Anforderungen geändert werden. Der Name darf nur Buchstaben, Zahlen und Bindestriche enthalten. | Architekt, Entwickler |
| Autorisieren Sie Ihre Bereitstellung für die Verwendung von Amazon Comprehend. | Obwohl Ihre Anwendung möglicherweise erfolgreich bereitgestellt wurde, sollten Sie Ihrer Bereitstellung auch Zugriff auf Amazon Comprehend gewähren. `ComprehendFullAccess`ist eine von AWS verwaltete Richtlinie, die der bereitgestellten Anwendung Berechtigungen zum Durchführen von API-Aufrufen an Amazon Comprehend gewährt.Fügen Sie die `ComprehendFullAccess` Richtlinie hinzu `aws-elasticbeanstalk-ec2-role` (diese Rolle wird automatisch für die Amazon Elastic Compute Cloud (Amazon EC2) -Instances Ihrer Bereitstellung erstellt), indem Sie den folgenden Befehl ausführen:`aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ComprehendFullAccess --role-name aws-elasticbeanstalk-ec2-role``aws-elasticbeanstalk-ec2-role`wird erstellt, wenn Ihre Anwendung bereitgestellt wird. Sie müssen den Bereitstellungsprozess abschließen, bevor Sie die AWS Identity and Access Management (IAM) -Richtlinie anhängen können. | Entwickler, Sicherheitsarchitekt |
| Besuchen Sie Ihre bereitgestellte Anwendung. | Nachdem Ihre Anwendung erfolgreich bereitgestellt wurde, können Sie sie aufrufen, indem Sie den `eb open` Befehl ausführen.Sie können den `eb status` Befehl auch ausführen, um Details zu Ihrer Bereitstellung zu erhalten. Die Bereitstellungs-URL ist unter aufgeführt`CNAME`. | Architekt, Entwickler |
### (Optional) Passen Sie die Anwendung an Ihr ML-Modell an
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Autorisieren Sie Elastic Beanstalk, auf das neue Modell zuzugreifen. | Stellen Sie sicher, dass Elastic Beanstalk über die erforderlichen Zugriffsberechtigungen für Ihren neuen Modellendpunkt verfügt. Wenn Sie beispielsweise einen SageMaker Amazon-Endpunkt verwenden, benötigt Ihre Bereitstellung die Erlaubnis, den Endpunkt aufzurufen. Weitere Informationen dazu finden Sie [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)in der SageMaker Amazon-Dokumentation. | Entwickler, Sicherheitsarchitekt |
| Senden Sie die Benutzerdaten an ein neues Modell. | Um das zugrunde liegende ML-Modell in dieser Anwendung zu ändern, müssen Sie die folgenden Dateien ändern:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Datenwissenschaftler |
| Aktualisieren Sie die Dashboard-Visualisierungen. | In der Regel bedeutet die Integration eines neuen ML-Modells, dass die Visualisierungen aktualisiert werden müssen, um die neuen Ergebnisse widerzuspiegeln. Diese Änderungen werden in den folgenden Dateien vorgenommen:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Web-Entwickler |
### (Optional) Stellen Sie die aktualisierte Anwendung bereit
| Aufgabe | Description | Erforderliche Fähigkeiten |
| --- | --- | --- |
| Aktualisieren Sie die Anforderungsdatei Ihrer Bewerbung. | Bevor Sie Änderungen an Elastic Beanstalk senden, aktualisieren Sie die `requirements.txt` Datei, sodass sie alle neuen Python-Module widerspiegelt, indem Sie den folgenden Befehl im Stammverzeichnis Ihrer Anwendung ausführen:`pip freeze > requirements.txt` | Python-Entwickler |
| Stellen Sie die Elastic Beanstalk Beanstalk-Umgebung erneut bereit. | Um sicherzustellen, dass Ihre Anwendungsänderungen in Ihrem Elastic Beanstalk-Deployment widergespiegelt werden, navigieren Sie zum Stammverzeichnis Ihrer Anwendung und führen Sie den folgenden Befehl aus:`eb deploy`Dadurch wird die neueste Version des Anwendungscodes an Ihr vorhandenes Elastic Beanstalk-Deployment gesendet. | Systemadministrator, Architekt |
## Zugehörige Ressourcen
+ [Rufen Sie mit Amazon API Gateway und AWS Lambda einen SageMaker Amazon-Modellendpunkt auf](https://aws.amazon.com/blogs/machine-learning/call-an-amazon-sagemaker-model-endpoint-using-amazon-api-gateway-and-aws-lambda/)
+ [Bereitstellung einer Flask-Anwendung auf Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html)
+ [EB CLI-Befehlsreferenz](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb3-cmd-commands.html)
+ [Einrichtung Ihrer Python-Entwicklungsumgebung](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html)
## Zusätzliche Informationen
**Liste der Problemlösungen**
Im Folgenden finden Sie sechs häufig auftretende Fehler und deren Lösungen.
***Fehler 1***
```
Unable to assume role "arn:aws:iam::xxxxxxxxxx:role/aws-elasticbeanstalk-ec2-role". Verify that the role exists and is configured correctly.
```
**Lösung**: Wenn dieser Fehler bei der Ausführung auftritt`eb create`, erstellen Sie eine Beispielanwendung auf der Elastic Beanstalk Beanstalk-Konsole, um das Standard-Instance-Profil zu erstellen. Weitere Informationen dazu finden Sie in der Dokumentation zu AWS [Elastic Beanstalk unter Creating an Elastic Beanstalk Environment](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.environments.html).
***Fehler 2***
```
Your WSGIPath refers to a file that does not exist.
```
**Lösung:** Dieser Fehler tritt in den Bereitstellungsprotokollen auf, weil Elastic Beanstalk erwartet, dass der Flask-Code benannt wird. `application.py` Wenn Sie einen anderen Namen gewählt haben, führen Sie den aus `eb config` und bearbeiten Sie ihn WSGIPath wie im folgenden Codebeispiel gezeigt:
```
aws:elasticbeanstalk:container:python:
NumProcesses: '1'
NumThreads: '15'
StaticFiles: /static/=static/
WSGIPath: application.py
```
Stellen Sie sicher, dass Sie es `application.py` durch Ihren Dateinamen ersetzen.
Sie können auch Gunicorn und ein Profil nutzen. Weitere Informationen zu diesem Ansatz finden Sie unter [Konfiguration des WSGI-Servers mit einem Profil in der AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-configuration-procfile.html) Beanstalk-Dokumentation.
***Fehler 3***
```
Target WSGI script '/opt/python/current/app/application.py' does not contain WSGI application 'application'.
```
**Lösung:** Elastic Beanstalk erwartet, dass die Variable, die Ihre Flask-Anwendung repräsentiert, benannt wird. `application` Stellen Sie sicher, dass die `application.py` Datei `application` als Variablennamen verwendet:
```
application = Flask(__name__)
```
***Fehler 4***
```
The EB CLI cannot find your SSH key file for keyname
```
**Lösung:** Verwenden Sie die EB-CLI, um anzugeben, welches key pair verwendet werden soll, oder um ein key pair für die EC2-Instances Ihrer Bereitstellung zu erstellen. Um den Fehler zu beheben, führen Sie den `eb init -i` Befehl aus und eine der Optionen wird Sie fragen:
```
Do you want to set up SSH for your instances?
```
Antworten Sie mit`Y`, um entweder ein key pair zu erstellen oder ein vorhandenes key pair anzugeben.
***Fehler 5***
*Ich habe meinen Code aktualisiert und erneut bereitgestellt, aber meine Bereitstellung spiegelt meine Änderungen nicht wider.*
**Lösung**: Wenn du ein Git-Repository mit deiner Bereitstellung verwendest, stelle sicher, dass du deine Änderungen hinzufügst und festschreibst, bevor du sie erneut bereitstellst.
***Fehler 6***
*Sie zeigen eine Vorschau der Flask-Anwendung von einer AWS Cloud9 Cloud9-IDE aus und stoßen auf Fehler.*
**Lösung:** Weitere Informationen dazu finden Sie unter [Vorschau laufender Anwendungen in der AWS Cloud9 Cloud9-IDE in der AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html) Cloud9-Dokumentation.
**Verarbeitung natürlicher Sprache mit Amazon Comprehend**
Wenn Sie sich für Amazon Comprehend entscheiden, können Sie benutzerdefinierte Entitäten in einzelnen Textdokumenten erkennen, indem Sie Echtzeitanalysen oder asynchrone Batch-Jobs ausführen. Mit Amazon Comprehend können Sie auch benutzerdefinierte Modelle zur Erkennung von Entitäten und zur Textklassifizierung trainieren, die in Echtzeit verwendet werden können, indem Sie einen Endpunkt erstellen.
Dieses Muster verwendet asynchrone Batch-Jobs, um Stimmungen und Entitäten aus einer Eingabedatei zu erkennen, die mehrere Dokumente enthält. Die in diesem Muster bereitgestellte Beispielanwendung ist so konzipiert, dass Benutzer eine CSV-Datei hochladen können, die eine einzelne Spalte mit einem Textdokument pro Zeile enthält. Die `comprehend_helper.py` Datei im Repository GitHub [Visualize AI/ML model results using Flask and AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) liest die Eingabedatei und sendet die Eingabe zur Verarbeitung an Amazon Comprehend.
*BatchDetectEntities*
Amazon Comprehend untersucht den Text eines Stapels von Dokumenten auf benannte Entitäten und gibt die erkannte Entität, den Standort, den [Entitätstyp und eine Bewertung zurück, die das Vertrauensniveau von](https://docs.aws.amazon.com/comprehend/latest/dg/how-entities.html) Amazon Comprehend angibt. In einem API-Aufruf können maximal 25 Dokumente gesendet werden, wobei jedes Dokument kleiner als 5.000 Byte ist. Sie können die Ergebnisse filtern, sodass nur bestimmte Entitäten angezeigt werden, die auf dem Anwendungsfall basieren. Sie könnten beispielsweise den `‘quantity’` Entitätstyp überspringen und einen Schwellenwert für die erkannte Entität festlegen (z. B. 0,75). Wir empfehlen Ihnen, die Ergebnisse für Ihren speziellen Anwendungsfall zu untersuchen, bevor Sie einen Schwellenwert auswählen. Weitere Informationen dazu finden Sie [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectEntities.html)in der Amazon Comprehend Comprehend-Dokumentation.
*BatchDetectSentiment*
Amazon Comprehend prüft einen Stapel eingehender Dokumente und gibt die vorherrschende Stimmung für jedes Dokument zurück (`POSITIVE`,`NEUTRAL`, `MIXED` oder). `NEGATIVE` In einem API-Aufruf können maximal 25 Dokumente gesendet werden, wobei jedes Dokument kleiner als 5.000 Byte ist. Die Stimmungsanalyse ist unkompliziert, und Sie wählen die Stimmung mit der höchsten Punktzahl aus, die in den Endergebnissen angezeigt werden soll. Weitere Informationen dazu finden Sie [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectSentiment.html)in der Amazon Comprehend Comprehend-Dokumentation.
**Handhabung der Flask-Konfiguration**
Flask-Server verwenden eine Reihe von [Konfigurationsvariablen](https://flask.palletsprojects.com/en/1.1.x/config/), um zu steuern, wie der Server läuft. Diese Variablen können Debug-Ausgaben, Sitzungstoken oder andere Anwendungseinstellungen enthalten. Sie können auch benutzerdefinierte Variablen definieren, auf die zugegriffen werden kann, während die Anwendung ausgeführt wird. Es gibt mehrere Ansätze zum Setzen von Konfigurationsvariablen.
In diesem Muster wird die Konfiguration definiert `config.py` und darin vererbt`application.py`.
+
**Anmerkung**
`config.py`enthält die Konfigurationsvariablen, die beim Start der Anwendung eingerichtet werden. In dieser Anwendung ist eine `DEBUG` Variable definiert, die der Anwendung mitteilt, den Server im [Debug-Modus](https://flask.palletsprojects.com/en/1.1.x/config/#DEBUG) auszuführen. : Der Debug-Modus sollte nicht verwendet werden, wenn eine Anwendung in einer Produktionsumgebung ausgeführt wird. `UPLOAD_FOLDER`ist eine benutzerdefinierte Variable, die so definiert ist, dass sie später in der Anwendung referenziert wird und sie darüber informiert, wo hochgeladene Benutzerdaten gespeichert werden sollen.
+ `application.py`initiiert die Flask-Anwendung und erbt die in definierten Konfigurationseinstellungen. `config.py` Dies wird durch den folgenden Code ausgeführt:
```
application = Flask(__name__)
application.config.from_pyfile('config.py')
```
# Mehr Muster
**Topics**
+ [Beschleunigen Sie MLOps mit Backstage- und Self-Service-Vorlagen für Amazon AI SageMaker](accelerate-mlops-with-backstage-and-sagemaker-templates.md)
+ [Automatisieren Sie den AWS Infrastrukturbetrieb mithilfe von Amazon Bedrock](automate-aws-infrastructure-operations-by-using-amazon-bedrock.md)
+ [Stellen Sie mithilfe von Terraform Agentensysteme auf Amazon Bedrock mit dem CrewAI-Framework bereit](deploy-agentic-systems-on-amazon-bedrock-with-the-crewai-framework.md)
+ [Stellen Sie eine ChatOps Lösung zur Verwaltung von SAST-Scanergebnissen bereit, indem Sie Amazon Q Developer in Chat-Anwendungen verwenden, benutzerdefinierte Aktionen und CloudFormation](deploy-chatops-solution-to-manage-sast-scan-results.md)
+ [Generieren Sie Dateneinblicke mithilfe AWS Mainframe Modernization von Amazon Q in Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Generieren Sie Einblicke in z/OS Db2-Daten mithilfe AWS Mainframe Modernization von Amazon Q in Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Geben Sie SageMaker Notebook-Instances temporären Zugriff auf ein CodeCommit Repository in einem anderen AWS-Konto](give-sagemaker-notebook-instances-temporary-access-to-a-codecommit-repository-in-another-aws-account.md)
+ [AWS Organizations Richtlinien mithilfe AWS CodePipeline von Amazon Bedrock als Code verwalten](manage-organizations-policies-as-code.md)
+ [Modernisieren Sie die CardDemo Mainframe-Anwendung mithilfe von AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernisieren und implementieren Sie Mainframe-Anwendungen mithilfe von Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Führen Sie erweiterte Analysen mit Amazon Redshift ML durch](perform-advanced-analytics-using-amazon-redshift-ml.md)
+ [Optimieren Sie das EC2 Amazon-Compliance-Management mit Amazon Bedrock-Agenten und AWS Config](streamline-amazon-ec2-compliance-management-with-amazon-bedrock-agents-and-aws-config.md)
+ [Optimieren Sie die Entwicklung und Bereitstellung von Amazon Lex Lex-Bot mithilfe eines automatisierten Workflows](streamline-amazon-lex-bot-development-and-deployment-using-an-automated-workflow.md)
+ [Fehlerbehebung bei Zuständen mithilfe AWS Step Functions von Amazon Bedrock](troubleshooting-states-in-aws-step-functions.md)