Pré-requisitos Crie um AWS Cloud Map namespace Criar uma tabela do DynamoDB Crie um serviço de AWS Cloud Map dados e registre a tabela do DynamoDB Crie uma função do IAM para funções Lambda Crie a função Lambda para gravar dados Crie um serviço de AWS Cloud Map aplicativo e registre a função de gravação do Lambda Crie a função Lambda para ler dados Registre a função de leitura do Lambda como uma instância de serviço Crie e execute aplicativos cliente Limpar recursos

Saiba como usar a descoberta AWS Cloud Map de serviços com atributos personalizados usando o AWS CLI

Este tutorial demonstra como você pode usar a descoberta AWS Cloud Map de serviços com atributos personalizados. Você criará um aplicativo de microsserviços usado AWS Cloud Map para descobrir recursos dinamicamente usando atributos personalizados. O aplicativo consiste em duas funções Lambda que gravam e lêem dados em uma tabela do DynamoDB, com todos os recursos registrados em. AWS Cloud Map

Para obter uma AWS Management Console versão do tutorial, consulteSaiba como usar a descoberta AWS Cloud Map de serviços com atributos personalizados.

Pré-requisitos

Antes de começar este tutorial, conclua as etapas emConfigurado para usar AWS Cloud Map.

Crie um AWS Cloud Map namespace

Um namespace é uma construção usada para agrupar serviços para um aplicativo. Nesta etapa, você criará um namespace que permite que os recursos sejam descobertos por meio AWS Cloud Map de chamadas de API.

Execute o comando a seguir para criar um namespace HTTP:


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

O comando retorna um ID de operação. Você pode verificar o status da operação com o seguinte comando:


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

Depois que o namespace for criado, você poderá recuperar seu ID para uso nos comandos subsequentes:


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

Armazene o ID do namespace em uma variável para uso posterior:


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

Criar uma tabela do DynamoDB

Em seguida, crie uma tabela do DynamoDB que armazenará dados para seu aplicativo:

Execute o comando a seguir para criar a tabela:


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

Aguarde até que a tabela fique ativa antes de continuar:
```
aws dynamodb wait table-exists --table-name cloudmap
```
Esse comando espera até que a tabela esteja totalmente criada e pronta para uso.

Crie um serviço de AWS Cloud Map dados e registre a tabela do DynamoDB

Agora, crie um serviço em seu namespace para representar os recursos de armazenamento de dados:

Execute o comando a seguir para criar um AWS Cloud Map serviço para recursos de armazenamento de dados:


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

Obtenha o ID do serviço de dados:


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

Registre a tabela do DynamoDB como uma instância de serviço com um atributo personalizado que especifica o nome da tabela:
```
aws servicediscovery register-instance \
  --service-id $DATA_SERVICE_ID \
  --instance-id data-instance \
  --attributes tablename=cloudmap
```
O atributo personalizado tablename=cloudmap permite que outros serviços descubram dinamicamente o nome da tabela do DynamoDB.

Crie uma função do IAM para funções Lambda

Crie uma função do IAM que as funções do Lambda usarão para acessar AWS recursos:

Crie o documento de política de confiança para a função do IAM:


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

Execute o comando a seguir para criar a função do IAM usando a política de confiança:


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

Crie um arquivo para uma política personalizada do IAM com menos permissões de privilégio:


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

Crie e anexe a política à função do 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

Crie a função Lambda para gravar dados

Para criar uma função Lambda que grava dados na tabela do DynamoDB, siga estas etapas:

Crie o arquivo Python para a função de gravação:


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

Essa função é usada AWS Cloud Map para descobrir o nome da tabela do DynamoDB a partir do atributo personalizado e, em seguida, grava dados na tabela.

Package e implante a função 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

Atualize o tempo limite da função para evitar erros de tempo limite:


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

Crie um serviço de AWS Cloud Map aplicativo e registre a função de gravação do Lambda

Para criar outro serviço em seu namespace para representar as funções do aplicativo, siga estas etapas:

Crie um serviço para funções do aplicativo:


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

Obtenha o ID do serviço do aplicativo:


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

Registre a função de gravação do Lambda como uma instância de serviço com atributos personalizados:
```
aws servicediscovery register-instance \
  --service-id $APP_SERVICE_ID \
  --instance-id write-instance \
  --attributes action=write,functionname=writefunction
```
Os atributos personalizados functionname=writefunction permitem que action=write os clientes descubram essa função com base em sua finalidade.

Crie a função Lambda para ler dados

Para criar uma função Lambda que leia dados da tabela do DynamoDB, siga estas etapas:

Crie o arquivo Python para a função de leitura:


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

Essa função também é usada AWS Cloud Map para descobrir o nome da tabela do DynamoDB e, em seguida, ler os dados da tabela. Inclui tratamento de erros e comentários de paginação.

Package e implante a função 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

Atualize o tempo limite da função:


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

Registre a função de leitura do Lambda como uma instância de serviço

Para registrar a função de leitura do Lambda como outra instância de serviço no serviço de aplicativo, siga esta etapa:


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

Os atributos personalizados functionname=readfunction permitem que action=read os clientes descubram essa função com base em sua finalidade.

Crie e execute aplicativos cliente

Para criar um aplicativo cliente Python que use AWS Cloud Map para descobrir e invocar a função de gravação, siga estas etapas:

Crie um arquivo Python para o aplicativo cliente de gravação:


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

Esse cliente usa a QueryParameters opção de encontrar instâncias de serviço com o action=write atributo.

Crie um arquivo Python para o aplicativo cliente de leitura:


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

Execute o cliente de gravação para adicionar dados à tabela do DynamoDB:
```
python3 writeclient.py
```
A saída deve mostrar uma resposta bem-sucedida com o código de status HTTP 200.
Execute o cliente de leitura para recuperar dados da tabela do DynamoDB:
```
python3 readclient.py
```
A saída deve mostrar os dados que foram gravados na tabela, incluindo o ID gerado aleatoriamente e o valor “Isto é um dado de teste”.

Limpar recursos

Ao concluir o tutorial, limpe os recursos para evitar cobranças adicionais.

Primeiro, execute o comando a seguir para cancelar o registro das instâncias do serviço:


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

Execute o comando a seguir para excluir os serviços:


aws servicediscovery delete-service \
  --id $APP_SERVICE_ID

aws servicediscovery delete-service \
  --id $DATA_SERVICE_ID

Execute o comando a seguir para excluir o namespace:


aws servicediscovery delete-namespace \
  --id $NAMESPACE_ID

Execute o comando a seguir para excluir as funções do Lambda:


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

Execute o comando a seguir para excluir a função e a política do 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

Execute o comando a seguir para excluir a tabela do DynamoDB:
```
aws dynamodb delete-table --table-name cloudmap
```

Execute o comando a seguir para limpar arquivos temporários:


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Use AWS Cloud Map com atributos personalizados

Namespaces