Prerequisiti Crea un AWS Cloud Map namespace Creazione di una tabella DynamoDB Creare un servizio AWS Cloud Map dati e registrare la tabella DynamoDB Creare un ruolo IAM per le funzioni Lambda Crea la funzione Lambda per scrivere dati Crea un servizio AWS Cloud Map app e registra la funzione di scrittura Lambda Crea la funzione Lambda per leggere i dati Registra la funzione di lettura Lambda come istanza di servizio Crea ed esegui applicazioni client Pulizia delle risorse

Scopri come utilizzare il rilevamento dei AWS Cloud Map servizi con attributi personalizzati utilizzando AWS CLI

Questo tutorial dimostra come utilizzare il rilevamento dei AWS Cloud Map servizi con attributi personalizzati. Creerai un'applicazione di microservizi che consente di AWS Cloud Map scoprire le risorse in modo dinamico utilizzando attributi personalizzati. L'applicazione è composta da due funzioni Lambda che scrivono e leggono dati in una tabella DynamoDB, con tutte le risorse registrate. AWS Cloud Map

Per una AWS Management Console versione del tutorial, vedi. Scopri come utilizzare il rilevamento dei AWS Cloud Map servizi con attributi personalizzati

Prerequisiti

Prima di iniziare questo tutorial, completa i passaggi indicati inConfigurazione per l'uso AWS Cloud Map.

Crea un AWS Cloud Map namespace

Un namespace è un costrutto utilizzato per raggruppare i servizi per un'applicazione. In questo passaggio, creerai uno spazio dei nomi che consente di individuare le risorse tramite chiamate API. AWS Cloud Map

Esegui il comando seguente per creare uno spazio dei nomi HTTP:


aws servicediscovery create-http-namespace \
  --name cloudmap-tutorial \
  --creator-request-id cloudmap-tutorial-request

Il comando restituisce un ID di operazione. È possibile controllare lo stato dell'operazione con il seguente comando:


aws servicediscovery get-operation \
  --operation-id operation-id

Una volta creato lo spazio dei nomi, è possibile recuperarne l'ID per utilizzarlo nei comandi successivi:


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

Memorizza l'ID dello spazio dei nomi in una variabile per un uso successivo:


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

Creazione di una tabella DynamoDB

Quindi, crea una tabella DynamoDB che memorizzerà i dati per la tua applicazione:

Esegui il comando seguente per creare la tabella:


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

Attendi che la tabella diventi attiva prima di procedere:
```
aws dynamodb wait table-exists --table-name cloudmap
```
Questo comando attende che la tabella sia completamente creata e pronta per l'uso.

Creare un servizio AWS Cloud Map dati e registrare la tabella DynamoDB

Ora, crea un servizio nel tuo namespace per rappresentare le risorse di archiviazione dei dati:

Esegui il comando seguente per creare un AWS Cloud Map servizio per le risorse di archiviazione dei dati:


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

Ottieni l'ID del servizio per il servizio dati:


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

Registra la tabella DynamoDB come istanza di servizio con un attributo personalizzato che specifica il nome della tabella:
```
aws servicediscovery register-instance \
  --service-id $DATA_SERVICE_ID \
  --instance-id data-instance \
  --attributes tablename=cloudmap
```
L'attributo personalizzato tablename=cloudmap consente ad altri servizi di scoprire il nome della tabella DynamoDB in modo dinamico.

Creare un ruolo IAM per le funzioni Lambda

Crea un ruolo IAM che le funzioni Lambda utilizzeranno per accedere AWS alle risorse:

Crea il documento sulla politica di fiducia per il ruolo IAM:


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

Esegui il comando seguente per creare il ruolo IAM utilizzando la policy di fiducia:


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

Crea un file per una policy IAM personalizzata con i permessi minimi:


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

Crea e collega la policy al ruolo IAM:


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

Crea la funzione Lambda per scrivere dati

Per creare una funzione Lambda che scrive dati nella tabella DynamoDB, segui questi passaggi:

Crea il file Python per la funzione di scrittura:


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

Questa funzione utilizza AWS Cloud Map per scoprire il nome della tabella DynamoDB dall'attributo personalizzato, quindi scrive i dati nella tabella.

Package e distribuzione della funzione Lambda:


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

Aggiorna il timeout della funzione per evitare errori di timeout:


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

Crea un servizio AWS Cloud Map app e registra la funzione di scrittura Lambda

Per creare un altro servizio nel tuo spazio dei nomi per rappresentare le funzioni dell'applicazione, procedi nel seguente modo:

Crea un servizio per le funzioni dell'applicazione:


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

Ottieni l'ID del servizio per il servizio dell'app:


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

Registra la funzione di scrittura Lambda come istanza di servizio con attributi personalizzati:
```
aws servicediscovery register-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id write-instance \
  --attributes action=write,functionname=writefunction
```
Gli attributi personalizzati functionname=writefunction consentono action=write ai client di scoprire questa funzione in base al suo scopo.

Crea la funzione Lambda per leggere i dati

Per creare una funzione Lambda che legge i dati dalla tabella DynamoDB, segui questi passaggi:

Crea il file Python per la funzione read:


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

Questa funzione utilizza anche AWS Cloud Map per scoprire il nome della tabella DynamoDB, quindi legge i dati dalla tabella. Include la gestione degli errori e i commenti di impaginazione.

Package e distribuzione della funzione Lambda:


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

Aggiorna il timeout della funzione:


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

Registra la funzione di lettura Lambda come istanza di servizio

Per registrare la funzione di lettura Lambda come un'altra istanza di servizio nel servizio app, procedi nel seguente passaggio:


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

Gli attributi personalizzati functionname=readfunction consentono action=read ai client di scoprire questa funzione in base al suo scopo.

Crea ed esegui applicazioni client

Per creare un'applicazione client Python da utilizzare AWS Cloud Map per scoprire e richiamare la funzione di scrittura, segui questi passaggi:

Crea un file Python per l'applicazione client di scrittura:


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

Questo client utilizza l'QueryParametersopzione per trovare istanze di servizio con l'action=writeattributo.

Crea un file Python per l'applicazione client di lettura:


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

Esegui il client di scrittura per aggiungere dati alla tabella DynamoDB:
```
python3 writeclient.py
```
L'output dovrebbe mostrare una risposta corretta con il codice di stato HTTP 200.
Esegui il client di lettura per recuperare i dati dalla tabella DynamoDB:
```
python3 readclient.py
```
L'output dovrebbe mostrare i dati che sono stati scritti nella tabella, incluso l'ID generato casualmente e il valore «This is a test data».

Pulizia delle risorse

Al termine del tutorial, ripulisci le risorse per evitare di incorrere in costi aggiuntivi.

Innanzitutto, esegui il comando seguente per annullare la registrazione delle istanze del servizio:


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

Eseguite il comando seguente per eliminare i servizi:


aws servicediscovery delete-service \
  --id $APP_SERVICE_ID

aws servicediscovery delete-service \
  --id $DATA_SERVICE_ID

Eseguite il comando seguente per eliminare lo spazio dei nomi:
```
aws servicediscovery delete-namespace \
  --id $NAMESPACE_ID
```

Esegui il comando seguente per eliminare le funzioni Lambda:


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

Esegui il comando seguente per eliminare il ruolo e la policy IAM:


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

Esegui il comando seguente per eliminare la tabella DynamoDB:
```
aws dynamodb delete-table --table-name cloudmap
```

Esegui il comando seguente per pulire i file temporanei:


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzare AWS Cloud Map con attributi personalizzati

Spazi dei nomi