Voraussetzungen Erstellen Sie einen AWS Cloud Map Namespace Erstellen einer DynamoDB-Tabelle Erstellen Sie einen AWS Cloud Map Datendienst und registrieren Sie die DynamoDB-Tabelle Erstellen Sie eine IAM-Rolle für Lambda-Funktionen Erstellen Sie die Lambda-Funktion zum Schreiben von Daten Erstellen Sie einen AWS Cloud Map App-Dienst und registrieren Sie die Lambda-Schreibfunktion Erstellen Sie die Lambda-Funktion zum Lesen von Daten Registrieren Sie die Lambda-Lesefunktion als Dienstinstanz Client-Anwendungen erstellen und ausführen Bereinigen von -Ressourcen

Erfahren Sie, wie Sie AWS Cloud Map Service Discovery mit benutzerdefinierten Attributen verwenden können, indem Sie AWS CLI

Dieses Tutorial zeigt, wie Sie AWS Cloud Map Service Discovery mit benutzerdefinierten Attributen verwenden können. Sie erstellen eine Microservices-Anwendung, die Ressourcen mithilfe benutzerdefinierter Attribute dynamisch erkennt. AWS Cloud Map Die Anwendung besteht aus zwei Lambda-Funktionen, die Daten in eine DynamoDB-Tabelle schreiben und aus einer DynamoDB-Tabelle lesen, in der alle Ressourcen registriert sind. AWS Cloud Map

Eine AWS Management Console Version des Tutorials finden Sie unter. Erfahren Sie, wie Sie AWS Cloud Map Service Discovery mit benutzerdefinierten Attributen verwenden

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, führen Sie die Schritte unter durchZur Verwendung eingerichtet AWS Cloud Map.

Erstellen Sie einen AWS Cloud Map Namespace

Ein Namespace ist ein Konstrukt, das verwendet wird, um Dienste für eine Anwendung zu gruppieren. In diesem Schritt erstellen Sie einen Namespace, der es ermöglicht, Ressourcen über AWS Cloud Map API-Aufrufe auffindbar zu machen.

Führen Sie den folgenden Befehl aus, um einen HTTP-Namespace zu erstellen:
```
aws servicediscovery create-http-namespace \
  --name cloudmap-tutorial \
  --creator-request-id cloudmap-tutorial-request
```
Der Befehl gibt eine Vorgangs-ID zurück. Sie können den Status des Vorgangs mit dem folgenden Befehl überprüfen:
```
aws servicediscovery get-operation \
  --operation-id operation-id
```

Sobald der Namespace erstellt wurde, können Sie seine ID zur Verwendung in nachfolgenden Befehlen abrufen:


aws servicediscovery list-namespaces \
  --query "Namespaces[?Name=='cloudmap-tutorial'].Id" \
  --output text

Speichern Sie die Namespace-ID zur späteren Verwendung in einer Variablen:


NAMESPACE_ID=$(aws servicediscovery list-namespaces \
  --query "Namespaces[?Name=='cloudmap-tutorial'].Id" \
  --output text)

Erstellen einer DynamoDB-Tabelle

Erstellen Sie als Nächstes eine DynamoDB-Tabelle, in der Daten für Ihre Anwendung gespeichert werden:

Führen Sie den folgenden Befehl aus, um die Tabelle zu erstellen:


aws dynamodb create-table \
  --table-name cloudmap \
  --attribute-definitions AttributeName=id,AttributeType=S \
  --key-schema AttributeName=id,KeyType=HASH \
  --billing-mode PAY_PER_REQUEST

Warten Sie, bis die Tabelle aktiv wird, bevor Sie fortfahren:
```
aws dynamodb wait table-exists --table-name cloudmap
```
Dieser Befehl wartet, bis die Tabelle vollständig erstellt und einsatzbereit ist.

Erstellen Sie einen AWS Cloud Map Datendienst und registrieren Sie die DynamoDB-Tabelle

Erstellen Sie nun einen Dienst in Ihrem Namespace, der Datenspeicherressourcen repräsentiert:

Führen Sie den folgenden Befehl aus, um einen AWS Cloud Map Dienst für Datenspeicherressourcen zu erstellen:


aws servicediscovery create-service \
  --name data-service \
  --namespace-id $NAMESPACE_ID \
  --creator-request-id data-service-request

Rufen Sie die Dienst-ID für den Datendienst ab:


DATA_SERVICE_ID=$(aws servicediscovery list-services \
  --query "Services[?Name=='data-service'].Id" \
  --output text)

Registrieren Sie die DynamoDB-Tabelle als Dienstinstanz mit einem benutzerdefinierten Attribut, das den Tabellennamen angibt:
```
aws servicediscovery register-instance \
  --service-id $DATA_SERVICE_ID \
  --instance-id data-instance \
  --attributes tablename=cloudmap
```
Das benutzerdefinierte Attribut tablename=cloudmap ermöglicht es anderen Diensten, den DynamoDB-Tabellennamen dynamisch zu ermitteln.

Erstellen Sie eine IAM-Rolle für Lambda-Funktionen

Erstellen Sie eine IAM-Rolle, die die Lambda-Funktionen für den Zugriff auf AWS Ressourcen verwenden:

Erstellen Sie das Dokument mit der Vertrauensrichtlinie für die IAM-Rolle:


cat > lambda-trust-policy.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
EOF

Führen Sie den folgenden Befehl aus, um die IAM-Rolle mithilfe der Vertrauensrichtlinie zu erstellen:


aws iam create-role \
  --role-name cloudmap-tutorial-role \
  --assume-role-policy-document file://lambda-trust-policy.json

Erstellen Sie eine Datei für eine benutzerdefinierte IAM-Richtlinie mit den geringsten Rechten:


cat > cloudmap-policy.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:*:*:*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "servicediscovery:DiscoverInstances"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:PutItem",
        "dynamodb:Scan"
      ],
      "Resource": "arn:aws:dynamodb:*:*:table/cloudmap"
    }
  ]
}
EOF

Erstellen Sie die Richtlinie und fügen Sie sie der IAM-Rolle hinzu:


aws iam create-policy \
  --policy-name CloudMapTutorialPolicy \
  --policy-document file://cloudmap-policy.json

POLICY_ARN=$(aws iam list-policies \
  --query "Policies[?PolicyName=='CloudMapTutorialPolicy'].Arn" \
  --output text)

aws iam attach-role-policy \
  --role-name cloudmap-tutorial-role \
  --policy-arn $POLICY_ARN

aws iam attach-role-policy \
  --role-name cloudmap-tutorial-role \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

Erstellen Sie die Lambda-Funktion zum Schreiben von Daten

Gehen Sie folgendermaßen vor, um eine Lambda-Funktion zu erstellen, die Daten in die DynamoDB-Tabelle schreibt:

Erstellen Sie die Python-Datei für die Schreibfunktion:


cat > writefunction.py << EOF
import json
import boto3
import random

def lambda_handler(event, context):
    try:
        serviceclient = boto3.client('servicediscovery')
        
        response = serviceclient.discover_instances(
            NamespaceName='cloudmap-tutorial',
            ServiceName='data-service')
        
        if not response.get("Instances"):
            return {
                'statusCode': 500,
                'body': json.dumps({"error": "No instances found"})
            }
            
        tablename = response["Instances"][0]["Attributes"].get("tablename")
        if not tablename:
            return {
                'statusCode': 500,
                'body': json.dumps({"error": "Table name attribute not found"})
            }
           
        dynamodbclient = boto3.resource('dynamodb')
           
        table = dynamodbclient.Table(tablename)
        
        # Validate input
        if not isinstance(event, str):
            return {
                'statusCode': 400,
                'body': json.dumps({"error": "Input must be a string"})
            }
           
        response = table.put_item(
            Item={ 'id': str(random.randint(1,100)), 'todo': event })
           
        return {
            'statusCode': 200,
            'body': json.dumps(response)
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({"error": str(e)})
        }
EOF

Diese Funktion ermittelt AWS Cloud Map den DynamoDB-Tabellennamen aus dem benutzerdefinierten Attribut und schreibt dann Daten in die Tabelle.

Package und implementieren Sie die Lambda-Funktion:


zip writefunction.zip writefunction.py

ROLE_ARN=$(aws iam get-role --role-name cloudmap-tutorial-role \
  --query 'Role.Arn' --output text)

aws lambda create-function \
  --function-name writefunction \
  --runtime python3.12 \
  --role $ROLE_ARN \
  --handler writefunction.lambda_handler \
  --zip-file fileb://writefunction.zip \
  --architectures x86_64

Aktualisieren Sie das Funktions-Timeout, um Timeout-Fehler zu vermeiden:


aws lambda update-function-configuration \
  --function-name writefunction \
  --timeout 5

Erstellen Sie einen AWS Cloud Map App-Dienst und registrieren Sie die Lambda-Schreibfunktion

Gehen Sie folgendermaßen vor, um in Ihrem Namespace einen weiteren Dienst zur Darstellung von Anwendungsfunktionen zu erstellen:

Erstellen Sie einen Dienst für Anwendungsfunktionen:


aws servicediscovery create-service \
  --name app-service \
  --namespace-id $NAMESPACE_ID \
  --creator-request-id app-service-request

Rufen Sie die Service-ID für den App-Dienst ab:


APP_SERVICE_ID=$(aws servicediscovery list-services \
  --query "Services[?Name=='app-service'].Id" \
  --output text)

Registrieren Sie die Lambda-Schreibfunktion als Dienstinstanz mit benutzerdefinierten Attributen:
```
aws servicediscovery register-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id write-instance \
  --attributes action=write,functionname=writefunction
```
Die benutzerdefinierten Attribute action=write functionname=writefunction ermöglichen es den Clients, diese Funktion anhand ihres Zwecks zu erkennen.

Erstellen Sie die Lambda-Funktion zum Lesen von Daten

Gehen Sie folgendermaßen vor, um eine Lambda-Funktion zu erstellen, die Daten aus der DynamoDB-Tabelle liest:

Erstellen Sie die Python-Datei für die Lesefunktion:


cat > readfunction.py << EOF
import json
import boto3

def lambda_handler(event, context):
    try:
        serviceclient = boto3.client('servicediscovery')

        response = serviceclient.discover_instances(
            NamespaceName='cloudmap-tutorial', 
            ServiceName='data-service')
        
        if not response.get("Instances"):
            return {
                'statusCode': 500,
                'body': json.dumps({"error": "No instances found"})
            }
            
        tablename = response["Instances"][0]["Attributes"].get("tablename")
        if not tablename:
            return {
                'statusCode': 500,
                'body': json.dumps({"error": "Table name attribute not found"})
            }
           
        dynamodbclient = boto3.resource('dynamodb')
           
        table = dynamodbclient.Table(tablename)
        
        # Use pagination for larger tables
        response = table.scan(
            Select='ALL_ATTRIBUTES',
            Limit=50  # Limit results for demonstration purposes
        )
        
        # For production, you would implement pagination like this:
        # items = []
        # while 'LastEvaluatedKey' in response:
        #     items.extend(response['Items'])
        #     response = table.scan(
        #         Select='ALL_ATTRIBUTES',
        #         ExclusiveStartKey=response['LastEvaluatedKey']
        #     )
        # items.extend(response['Items'])

        return {
            'statusCode': 200,
            'body': json.dumps(response)
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({"error": str(e)})
        }
EOF

Diese Funktion ermittelt AWS Cloud Map auch den DynamoDB-Tabellennamen und liest dann Daten aus der Tabelle. Sie umfasst Kommentare zur Fehlerbehandlung und Seitennummerierung.

Package und implementieren Sie die Lambda-Funktion:


zip readfunction.zip readfunction.py

aws lambda create-function \
  --function-name readfunction \
  --runtime python3.12 \
  --role $ROLE_ARN \
  --handler readfunction.lambda_handler \
  --zip-file fileb://readfunction.zip \
  --architectures x86_64

Aktualisieren Sie das Funktions-Timeout:


aws lambda update-function-configuration \
  --function-name readfunction \
  --timeout 5

Registrieren Sie die Lambda-Lesefunktion als Dienstinstanz

Gehen Sie wie folgt vor, um die Lambda-Lesefunktion als weitere Dienstinstanz im App-Dienst zu registrieren:


aws servicediscovery register-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id read-instance \
  --attributes action=read,functionname=readfunction

Die benutzerdefinierten Attribute action=read functionname=readfunction ermöglichen es den Clients, diese Funktion anhand ihres Zwecks zu erkennen.

Client-Anwendungen erstellen und ausführen

Gehen Sie folgendermaßen vor, um eine Python-Client-Anwendung AWS Cloud Map zu erstellen, mit der die Schreibfunktion erkannt und aufgerufen wird:

Erstellen Sie eine Python-Datei für die Schreibclient-Anwendung:


cat > writeclient.py << EOF
import boto3
import json

try:
    serviceclient = boto3.client('servicediscovery')

    print("Discovering write function...")
    response = serviceclient.discover_instances(
        NamespaceName='cloudmap-tutorial', 
        ServiceName='app-service', 
        QueryParameters={ 'action': 'write' }
    )

    if not response.get("Instances"):
        print("Error: No instances found")
        exit(1)
        
    functionname = response["Instances"][0]["Attributes"].get("functionname")
    if not functionname:
        print("Error: Function name attribute not found")
        exit(1)
        
    print(f"Found function: {functionname}")

    lambdaclient = boto3.client('lambda')

    print("Invoking Lambda function...")
    resp = lambdaclient.invoke(
        FunctionName=functionname, 
        Payload='"This is a test data"'
    )

    payload = resp["Payload"].read()
    print(f"Response: {payload.decode('utf-8')}")
    
except Exception as e:
    print(f"Error: {str(e)}")
EOF

Dieser Client verwendet die QueryParameters Option, um Dienstinstanzen mit dem action=write Attribut zu finden.

Erstellen Sie eine Python-Datei für die Readclient-Anwendung:


cat > readclient.py << EOF
import boto3
import json

try:
    serviceclient = boto3.client('servicediscovery')

    print("Discovering read function...")
    response = serviceclient.discover_instances(
        NamespaceName='cloudmap-tutorial', 
        ServiceName='app-service', 
        QueryParameters={ 'action': 'read' }
    )

    if not response.get("Instances"):
        print("Error: No instances found")
        exit(1)
        
    functionname = response["Instances"][0]["Attributes"].get("functionname")
    if not functionname:
        print("Error: Function name attribute not found")
        exit(1)
        
    print(f"Found function: {functionname}")

    lambdaclient = boto3.client('lambda')

    print("Invoking Lambda function...")
    resp = lambdaclient.invoke(
        FunctionName=functionname, 
        InvocationType='RequestResponse'
    )

    payload = resp["Payload"].read()
    print(f"Response: {payload.decode('utf-8')}")
    
except Exception as e:
    print(f"Error: {str(e)}")
EOF

Führen Sie den Schreibclient aus, um der DynamoDB-Tabelle Daten hinzuzufügen:
```
python3 writeclient.py
```
Die Ausgabe sollte eine erfolgreiche Antwort mit dem HTTP-Statuscode 200 anzeigen.
Führen Sie den Leseclient aus, um Daten aus der DynamoDB-Tabelle abzurufen:
```
python3 readclient.py
```
Die Ausgabe sollte die Daten enthalten, die in die Tabelle geschrieben wurden, einschließlich der zufällig generierten ID und des Werts „Dies sind Testdaten“.

Bereinigen von -Ressourcen

Wenn Sie mit dem Tutorial fertig sind, bereinigen Sie die Ressourcen, um zusätzliche Kosten zu vermeiden.

Führen Sie zunächst den folgenden Befehl aus, um die Registrierung der Dienstinstanzen aufzuheben:


aws servicediscovery deregister-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id read-instance

aws servicediscovery deregister-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id write-instance

aws servicediscovery deregister-instance \
  --service-id $DATA_SERVICE_ID \
  --instance-id data-instance

Führen Sie den folgenden Befehl aus, um die Dienste zu löschen:


aws servicediscovery delete-service \
  --id $APP_SERVICE_ID

aws servicediscovery delete-service \
  --id $DATA_SERVICE_ID

Führen Sie den folgenden Befehl aus, um den Namespace zu löschen:
```
aws servicediscovery delete-namespace \
  --id $NAMESPACE_ID
```

Führen Sie den folgenden Befehl aus, um die Lambda-Funktionen zu löschen:


aws lambda delete-function --function-name writefunction
aws lambda delete-function --function-name readfunction

Führen Sie den folgenden Befehl aus, um die IAM-Rolle und -Richtlinie zu löschen:


aws iam detach-role-policy \
  --role-name cloudmap-tutorial-role \
  --policy-arn $POLICY_ARN

aws iam detach-role-policy \
  --role-name cloudmap-tutorial-role \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

aws iam delete-policy \
  --policy-arn $POLICY_ARN

aws iam delete-role --role-name cloudmap-tutorial-role

Führen Sie den folgenden Befehl aus, um die DynamoDB-Tabelle zu löschen:
```
aws dynamodb delete-table --table-name cloudmap
```

Führen Sie den folgenden Befehl aus, um temporäre Dateien zu bereinigen:


rm -f lambda-trust-policy.json cloudmap-policy.json writefunction.py readfunction.py writefunction.zip readfunction.zip writeclient.py readclient.py

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

AWS Cloud Map Mit benutzerdefinierten Attributen verwenden

Namespaces