Prérequis Création d'un espace AWS Cloud Map de noms Créez une table DynamoDB Création d'un service de AWS Cloud Map données et enregistrement de la table DynamoDB Création d'un rôle IAM pour les fonctions Lambda Créez la fonction Lambda pour écrire des données Créez un service d' AWS Cloud Map application et enregistrez la fonction d'écriture Lambda Créez la fonction Lambda pour lire les données Enregistrez la fonction de lecture Lambda en tant qu'instance de service Création et exécution d'applications clientes Nettoyage des ressources

Apprenez à utiliser la découverte AWS Cloud Map de services avec des attributs personnalisés à l'aide du AWS CLI

Ce didacticiel explique comment utiliser la découverte AWS Cloud Map de services avec des attributs personnalisés. Vous allez créer une application de microservices qui permet de découvrir les ressources de manière dynamique AWS Cloud Map à l'aide d'attributs personnalisés. L'application se compose de deux fonctions Lambda qui écrivent et lisent des données dans une table DynamoDB, toutes les ressources y étant enregistrées. AWS Cloud Map

Pour une AWS Management Console version du didacticiel, voirDécouvrez comment utiliser la découverte AWS Cloud Map de services avec des attributs personnalisés.

Prérequis

Avant de commencer ce didacticiel, suivez les étapes décrites dansConfigurer pour utiliser AWS Cloud Map.

Création d'un espace AWS Cloud Map de noms

Un espace de noms est une construction utilisée pour regrouper les services d'une application. Au cours de cette étape, vous allez créer un espace de noms qui permet de découvrir les ressources via des appels d' AWS Cloud Map API.

Exécutez la commande suivante pour créer un espace de noms HTTP :
```
aws servicediscovery create-http-namespace \
  --name cloudmap-tutorial \
  --creator-request-id cloudmap-tutorial-request
```
La commande renvoie un identifiant d'opération. Vous pouvez vérifier le statut de l'opération à l'aide de la commande suivante :
```
aws servicediscovery get-operation \
  --operation-id operation-id
```
Une fois l'espace de noms créé, vous pouvez récupérer son identifiant pour l'utiliser dans les commandes suivantes :
```
aws servicediscovery list-namespaces \
  --query "Namespaces[?Name=='cloudmap-tutorial'].Id" \
  --output text
```

Stockez l'ID de l'espace de noms dans une variable pour une utilisation ultérieure :


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

Créez une table DynamoDB

Créez ensuite une table DynamoDB qui stockera les données de votre application :

Exécutez la commande suivante pour créer la table :


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

Attendez que la table soit active avant de continuer :
```
aws dynamodb wait table-exists --table-name cloudmap
```
Cette commande attend que la table soit complètement créée et prête à être utilisée.

Création d'un service de AWS Cloud Map données et enregistrement de la table DynamoDB

Créez maintenant un service dans votre espace de noms pour représenter les ressources de stockage de données :

Exécutez la commande suivante pour créer un AWS Cloud Map service pour les ressources de stockage de données :


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

Obtenez l'identifiant du service de données :


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

Enregistrez la table DynamoDB en tant qu'instance de service avec un attribut personnalisé qui spécifie le nom de la table :
```
aws servicediscovery register-instance \
  --service-id $DATA_SERVICE_ID \
  --instance-id data-instance \
  --attributes tablename=cloudmap
```
L'attribut personnalisé tablename=cloudmap permet aux autres services de découvrir le nom de la table DynamoDB de manière dynamique.

Création d'un rôle IAM pour les fonctions Lambda

Créez un rôle IAM que les fonctions Lambda utiliseront pour accéder aux AWS ressources :

Créez le document de politique de confiance pour le rôle IAM :


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

Exécutez la commande suivante pour créer le rôle IAM à l'aide de la politique de confiance :


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

Créez un fichier pour une politique IAM personnalisée avec les autorisations de moindre privilège :


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

Créez et associez la politique au rôle 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

Créez la fonction Lambda pour écrire des données

Pour créer une fonction Lambda qui écrit des données dans la table DynamoDB, procédez comme suit :

Créez le fichier Python pour la fonction d'écriture :


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

Cette fonction permet AWS Cloud Map de découvrir le nom de la table DynamoDB à partir de l'attribut personnalisé, puis d'écrire des données dans la table.

Package et déploiement de la fonction 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

Mettez à jour le délai d'expiration de la fonction pour éviter les erreurs de temporisation :
```
aws lambda update-function-configuration \
  --function-name writefunction \
  --timeout 5
```

Créez un service d' AWS Cloud Map application et enregistrez la fonction d'écriture Lambda

Pour créer un autre service dans votre espace de noms afin de représenter les fonctions de l'application, procédez comme suit :

Créez un service pour les fonctions de l'application :


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

Obtenez l'identifiant du service d'application :


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

Enregistrez la fonction d'écriture Lambda en tant qu'instance de service avec des attributs personnalisés :
```
aws servicediscovery register-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id write-instance \
  --attributes action=write,functionname=writefunction
```
Les attributs personnalisés functionname=writefunction permettent action=write aux clients de découvrir cette fonction en fonction de son objectif.

Créez la fonction Lambda pour lire les données

Pour créer une fonction Lambda qui lit les données de la table DynamoDB, procédez comme suit :

Créez le fichier Python pour la fonction de lecture :


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

Cette fonction permet également AWS Cloud Map de découvrir le nom de la table DynamoDB, puis de lire les données de la table. Il inclut la gestion des erreurs et les commentaires de pagination.

Package et déploiement de la fonction 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

Mettez à jour le délai d'expiration de la fonction :


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

Enregistrez la fonction de lecture Lambda en tant qu'instance de service

Pour enregistrer la fonction de lecture Lambda en tant qu'autre instance de service dans le service d'application, procédez comme suit :


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

Les attributs personnalisés functionname=readfunction permettent action=read aux clients de découvrir cette fonction en fonction de son objectif.

Création et exécution d'applications clientes

Pour créer une application cliente Python qui AWS Cloud Map découvre et invoque la fonction d'écriture, procédez comme suit :

Créez un fichier Python pour l'application cliente d'écriture :


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

Ce client utilise l'QueryParametersoption pour rechercher des instances de service avec l'action=writeattribut.

Créez un fichier Python pour l'application cliente de lecture :


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

Exécutez le client d'écriture pour ajouter des données à la table DynamoDB :
```
python3 writeclient.py
```
La sortie doit afficher une réponse réussie avec le code d'état HTTP 200.
Exécutez le client de lecture pour récupérer les données de la table DynamoDB :
```
python3 readclient.py
```
La sortie doit afficher les données écrites dans la table, y compris l'identifiant généré de manière aléatoire et la valeur « Ceci est une donnée de test ».

Nettoyage des ressources

Lorsque vous avez terminé le didacticiel, nettoyez les ressources pour éviter d'encourir des frais supplémentaires.

Exécutez d'abord la commande suivante pour désenregistrer les instances de service :


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

Exécutez la commande suivante pour supprimer les services :


aws servicediscovery delete-service \
  --id $APP_SERVICE_ID

aws servicediscovery delete-service \
  --id $DATA_SERVICE_ID

Exécutez la commande suivante pour supprimer l'espace de noms :
```
aws servicediscovery delete-namespace \
  --id $NAMESPACE_ID
```

Exécutez la commande suivante pour supprimer les fonctions Lambda :


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

Exécutez la commande suivante pour supprimer le rôle et la politique 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

Exécutez la commande suivante pour supprimer la table DynamoDB :
```
aws dynamodb delete-table --table-name cloudmap
```

Exécutez la commande suivante pour nettoyer les fichiers temporaires :


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

À utiliser AWS Cloud Map avec des attributs personnalisés

Espaces de noms