Uso de resolvedores HTTP no AWS AppSync

O AWS AppSync permite que você use fontes de dados compatíveis (ou seja, AWS Lambda, Amazon DynamoDB, Amazon OpenSearch Service ou Amazon Aurora) para executar diversas operações, além de quaisquer endpoints HTTP arbitrários para resolver campos do GraphQL. Depois que os endpoints HTTP estiverem disponíveis, conecte-se a eles usando uma fonte de dados. Em seguida, configure um resolvedor no esquema para executar operações do GraphQL, como consultas, mutações e assinaturas. Esse tutorial apresentará alguns exemplos comuns.

Neste tutorial, você usa uma API REST (criada usando Amazon API Gateway e Lambda) com um endpoint AWS AppSync do GraphQL.

Criar uma API REST

É possível usar o modelo AWS CloudFormation a seguir para configurar um endpoint REST que funcione para este tutorial:

A pilha do AWS CloudFormation realiza as seguintes etapas:

1. Configura uma função do Lambda, que contém a lógica de negócios para o seu microsserviço.

2. Configura uma API REST da API Gateway com a seguinte combinação de endpoint/método/tipo de conteúdo:

Caminho do recurso da API	Método HTTP	Tipo de conteúdo compatível
/v1/users	POST	application/json
/v1/users	GET	application/json
/v1/users/1	GET	application/json
/v1/users/1	PUT	application/json
/v1/users/1	DELETE	application/json

Criação da API GraphQL

Para criar a API GraphQL no AWS AppSync:

1. Abra o console do AWS AppSync e selecione Criar API.

2. Escolha APIs GraphQL e, em seguida, escolha Design do zero. Escolha Próximo.

3. Para o nome da API, digite UserData. Escolha Próximo.

4. Selecione Create GraphQL resources later. Escolha Próximo.

5. Revise suas entradas e selecione Criar API.

O console do AWS AppSync cria uma nova API GraphQL para você usando o modo de autenticação da chave da API. Você pode usar o console para configurar ainda mais sua API GraphQL e executar solicitações.

Criar um esquema do GraphQL

Agora que você tem uma API GraphQL, vamos criar um esquema do GraphQL. No editor Esquema no console do AWS AppSync, use o trecho abaixo:

type Mutation {
    addUser(userInput: UserInput!): User
    deleteUser(id: ID!): User
}

type Query {
    getUser(id: ID): User
    listUser: [User!]!
}

type User {
    id: ID!
    username: String!
    firstname: String
    lastname: String
    phone: String
    email: String
}

input UserInput {
    id: ID!
    username: String!
    firstname: String
    lastname: String
    phone: String
    email: String
}

Configurar a fonte de dados HTTP

Para configurar a fonte de dados HTTP, faça o seguinte:

1. Na página Fontes de dados da API AWS AppSync do GraphQL, escolha Criar fonte de dados.

2. Insira um nome para a fonte de dados como HTTP_Example.

3. Em Tipo de fonte de dados, escolha Endpoint de HTTP.

4. Configure o endpoint para o endpoint da API Gateway que foi criado no início do tutorial. Você pode encontrar seu endpoint gerado pela pilha navegando até o console do Lambda e encontrando seu aplicativo em Aplicativos. Dentro das configurações do seu aplicativo, você verá um endpoint de API que será seu endpoint no AWS AppSync. Lembre-se de não incluir o nome do estágio como parte do endpoint. Por exemplo, se o seu endpoint fosse https://aaabbbcccd.execute-api.us-east-1.amazonaws.com/v1, você digitaria https://aaabbbcccd.execute-api.us-east-1.amazonaws.com.

nota

No momento, somente endpoints públicos são compatíveis com o AWS AppSync.

Para obter mais informações sobre as autoridades certificadoras reconhecidas pelo serviço AWS AppSync, consulte Autoridades de certificação (CA) reconhecidas pelo AWS AppSync para endpoints HTTPS.

Configuração de resolvedores

Nesta etapa, você conectará a fonte de dados HTTP às consultas getUser e addUser.

Como configurar o resolvedor getUser:

1. Na API AWS AppSync do GraphQL, escolha a guia Esquema.

2. À direita do editor Esquema, no painel Resolvedores e em tipo Consulta, encontre o campo getUser e escolha Anexar.

3. Mantenha o tipo de resolvedor como Unit e o runtime como APPSYNC_JS.

4. Em Nome da fonte de dados, escolha o endpoint HTTP que você criou anteriormente.

5. Escolha Criar.

6. No editor de código Resolvedor, adicione o seguinte trecho como seu manipulador de solicitação:

   import { util } from '@aws-appsync/utils'
   
   export function request(ctx) {
   	return {
   		version: '2018-05-29',
   		method: 'GET',
   		params: {
   			headers: {
   				'Content-Type': 'application/json',
   			},
   		},
   		resourcePath: `/v1/users/${ctx.args.id}`,
   	}
   }

7. Adicione o seguinte trecho como seu manipulador de respostas:

   export function response(ctx) {
   	const { statusCode, body } = ctx.result
   	// if response is 200, return the response
   	if (statusCode === 200) {
   		return JSON.parse(body)
   	}
   	// if response is not 200, append the response to error block.
   	util.appendError(body, statusCode)
   }

8. Escolha a guia Consulta e, depois, execute a seguinte consulta:

   query GetUser{
       getUser(id:1){
           id
           username
       }
   }

   Isso deve retornar a seguinte resposta:

   {
       "data": {
           "getUser": {
               "id": "1",
               "username": "nadia"
           }
       }
   }

Como configurar o resolvedor addUser:

1. Escolha a guia Esquema.

2. À direita do editor Esquema, no painel Resolvedores e em tipo Consulta, encontre o campo addUser e escolha Anexar.

3. Mantenha o tipo de resolvedor como Unit e o runtime como APPSYNC_JS.

4. Em Nome da fonte de dados, escolha o endpoint HTTP que você criou anteriormente.

5. Escolha Criar.

6. No editor de código Resolvedor, adicione o seguinte trecho como seu manipulador de solicitação:

   export function request(ctx) {
       return {
           "version": "2018-05-29",
           "method": "POST",
           "resourcePath": "/v1/users",
           "params":{
               "headers":{
                   "Content-Type": "application/json"
               },
           "body": ctx.args.userInput
           }
       }
   }

7. Adicione o seguinte trecho como seu manipulador de respostas:

   export function response(ctx) {
       if(ctx.error) {
           return util.error(ctx.error.message, ctx.error.type)
       }
       if (ctx.result.statusCode == 200) {
           return ctx.result.body
       } else {
           return util.appendError(ctx.result.body, "ctx.result.statusCode")
       }
   }

8. Escolha a guia Consulta e, depois, execute a seguinte consulta:

   mutation addUser{
       addUser(userInput:{
           id:"2",
           username:"shaggy"
       }){
           id
           username
       }
   }

   Se você executar a consulta getUser novamente, ela deverá retornar a seguinte resposta:

   {
       "data": {
           "getUser": {
           "id": "2",
           "username": "shaggy"
           }
       }
   }

Invocar serviços da AWS

É possível usar resolvedores HTTP para configurar uma interface de API GraphQL para serviços da AWS. As solicitações HTTP para AWS devem ser assinadas com o Processo do Signature versão 4 para que a AWS seja possível identificar quem as enviou. AWS O AppSync calcula a assinatura em seu nome quando você associa um perfil do IAM à fonte de dados HTTP.

Você fornece dois componentes adicionais para invocar serviços da AWS com resolvedores HTTP:

• Um perfil do IAM com permissões para chamar as APIs de serviço da AWS

• Configurar a assinatura na fonte de dados

Por exemplo, se você quiser chamar a operação ListGraphqlApis com resolvedores HTTP, primeiro crie um perfil do IAM a ser assumida pelo AWS AppSync com a seguinte política associada:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "appsync:ListGraphqlApis"
            ],
            "Effect": "Allow",
            "Resource": "*"
        }
    ]
}

Depois, crie a fonte de dados HTTP para o AWS AppSync. Neste exemplo, você chamará AWS AppSync na região Oeste dos EUA (Oregon). Configure a seguinte configuração HTTP em um arquivo chamado http.json, que inclui a região de assinatura e o nome do serviço:

{
    "endpoint": "https://appsync.us-west-2.amazonaws.com/",
    "authorizationConfig": {
        "authorizationType": "AWS_IAM",
        "awsIamConfig": {
            "signingRegion": "us-west-2",
            "signingServiceName": "appsync"
        }
    }
}

Depois, use a AWS CLI para criar a fonte de dados com uma função associada da seguinte forma:

aws appsync create-data-source --api-id <API-ID> \
                               --name AWSAppSync \
                               --type HTTP \
                               --http-config file:///http.json \
                               --service-role-arn <ROLE-ARN>

Ao associar um resolvedor ao campo no esquema, use o seguinte modelo de mapeamento de solicitação para chamar AWS AppSync:

{
    "version": "2018-05-29",
    "method": "GET",
    "resourcePath": "/v1/apis"
}

Quando você executa uma consulta do GraphQL para essa fonte de dados, o AWS AppSync assina a solicitação usando a função fornecida e inclui a assinatura na solicitação. A consulta retorna uma lista de APIs AWS AppSync do GraphQL em sua conta nessa região da AWS.