Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso de resolutores HTTP en AWS AppSync
AWS AppSync le permite utilizar fuentes de datos compatibles (es decir, Amazon DynamoDB AWS Lambda, Amazon Service o Amazon Aurora) para realizar diversas operaciones, además de cualquier punto de enlace HTTP arbitrario para resolver los campos de GraphQL. OpenSearch Una vez que los puntos de enlace HTTP están disponibles, puede conectar con ellos mediante un origen de datos. A continuación, puede configurar un solucionador en el esquema para realizar operaciones de GraphQL como consultas, mutaciones, y suscripciones. Este tutorial le guiará a lo largo de algunos ejemplos comunes.
En este tutorial, utilizará una API REST (creada con Amazon API Gateway y Lambda) con un punto final de GraphQL AWS AppSync .
## Creación de una API de REST
Puede usar la siguiente AWS CloudFormation plantilla para configurar un punto final de REST que funcione para este tutorial:
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/http/http-api-gw.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/http/http-api-gw.yaml)
La AWS CloudFormation pila realiza los siguientes pasos:
1. Configura una función Lambda que contiene la lógica de negocio del microservicio.
1. Configura una API REST de API Gateway con la siguiente combinación endpoint/method/content de tipos:
****
| Ruta de recurso de la API | Método HTTP | Tipo de contenido admitido |
| --- | --- | --- |
| /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 |
## Creación de la API de GraphQL
Para crear la API GraphQL en: AWS AppSync
1. Abre la AWS AppSync consola y selecciona **Crear API**.
1. Elige **GraphQL APIs** y, a continuación, selecciona **Diseñar desde cero**. Elija **Siguiente**.
1. En el nombre de la API, introduzca `UserData`. Elija **Siguiente**.
1. Elija `Create GraphQL resources later`. Elija **Siguiente**.
1. Revise las entradas y seleccione **Crear API**.
La AWS AppSync consola crea una nueva API de GraphQL para usted mediante el modo de autenticación con clave de API. Puede utilizar la consola para configurar aún más la API de GraphQL y ejecutar solicitudes.
## Creación de un esquema de GraphQL
Ahora que tiene una API de GraphQL, vamos a crear un esquema de GraphQL. En el editor de **esquemas** de la AWS AppSync consola, usa el siguiente fragmento:
```
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
}
```
## Configure el origen de datos HTTP
Para configurar el origen de datos HTTP, haga lo siguiente:
1. En la página **Fuentes de datos** de tu API de AWS AppSync GraphQL, selecciona **Crear fuente de datos**.
1. Escriba un nombre para el origen de datos como `HTTP_Example`.
1. En **Tipo de origen de datos**, elija **Punto de conexión HTTP**.
1. Establezca el punto de conexión en el punto de conexión de la puerta de enlace de API que se creó al principio del tutorial. Para encontrar el punto de conexión generado por la pila, vaya a la consola de Lambda y busque su aplicación en **Aplicaciones**. Dentro de la configuración de la aplicación, debería ver un **punto de conexión de API**, que será su punto de conexión en AWS AppSync. Asegúrese de no incluir el nombre de etapa como parte del punto de conexión. Por ejemplo, si su punto de conexión fuera `https://aaabbbcccd.execute-api.us-east-1.amazonaws.com/v1`, escribiría `https://aaabbbcccd.execute-api.us-east-1.amazonaws.com`.
**nota**
En este momento, solo se admiten puntos finales públicos. AWS AppSync
Para obtener más información sobre las autoridades de certificación reconocidas por el AWS AppSync servicio, consulte [Autoridades de certificación (CA) reconocidas AWS AppSync por los puntos de enlace HTTPS](http-cert-authorities.md#aws-appsync-http-certificate-authorities).
## Configuración de solucionadores
En este paso conectará el origen de datos HTTP a las consultas `getUser` y `addUser`.
Para configurar el solucionador de `getUser`:
1. En tu API de AWS AppSync GraphQL, selecciona la pestaña **Esquema**.
1. A la derecha del editor **Esquema**, en el panel **Solucionadores** y en la sección de tipo **Consulta**, busque el campo `getUser` y seleccione **Asociar**.
1. Mantenga el tipo de solucionador en `Unit` y el tiempo de ejecución en `APPSYNC_JS`.
1. En **Nombre del origen de datos**, elija el punto de conexión HTTP que creó anteriormente.
1. Seleccione **Crear**.
1. En el editor de código **Solucionador**, añada el siguiente fragmento como controlador de solicitudes:
```
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}`,
}
}
```
1. Añada el siguiente fragmento como controlador de respuestas:
```
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)
}
```
1. Elija la pestaña **Query (Consulta)** y ejecute la consulta siguiente:
```
query GetUser{
getUser(id:1){
id
username
}
}
```
Debe obtener la siguiente respuesta:
```
{
"data": {
"getUser": {
"id": "1",
"username": "nadia"
}
}
}
```
Para configurar el solucionador de `addUser`:
1. Elija la pestaña **Schema (Esquema)**.
1. A la derecha del editor **Esquema**, en el panel **Solucionadores** y en la sección de tipo **Consulta**, busque el campo `addUser` y seleccione **Asociar**.
1. Mantenga el tipo de solucionador en `Unit` y el tiempo de ejecución en `APPSYNC_JS`.
1. En **Nombre del origen de datos**, elija el punto de conexión HTTP que creó anteriormente.
1. Seleccione **Crear**.
1. En el editor de código **Solucionador**, añada el siguiente fragmento como controlador de solicitudes:
```
export function request(ctx) {
return {
"version": "2018-05-29",
"method": "POST",
"resourcePath": "/v1/users",
"params":{
"headers":{
"Content-Type": "application/json"
},
"body": ctx.args.userInput
}
}
}
```
1. Añada el siguiente fragmento como controlador de respuestas:
```
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")
}
}
```
1. Elija la pestaña **Query (Consulta)** y ejecute la consulta siguiente:
```
mutation addUser{
addUser(userInput:{
id:"2",
username:"shaggy"
}){
id
username
}
}
```
Si vuelve a ejecutar la consulta `getUser`, debería devolver la siguiente respuesta:
```
{
"data": {
"getUser": {
"id": "2",
"username": "shaggy"
}
}
}
```
## Invocando servicios AWS
Puedes usar resolutores HTTP para configurar una interfaz AWS API de GraphQL para los servicios. Las solicitudes HTTP AWS deben firmarse con el [proceso Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) para AWS poder identificar quién las envió. AWS AppSync calcula la firma en su nombre al asociar una función de IAM a la fuente de datos HTTP.
Usted proporciona dos componentes adicionales para invocar AWS servicios con resolutores HTTP:
+ Un rol de IAM con permisos para llamar al servicio AWS APIs
+ Configuración de la firma en el origen de datos
Por ejemplo, si desea llamar a la [ListGraphqlApis operación](https://docs.aws.amazon.com/appsync/latest/APIReference/API_ListGraphqlApis.html) con resolutores HTTP, primero debe [crear un rol de IAM](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch) que AWS AppSync asuma la siguiente política adjunta:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appsync:ListGraphqlApis"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
A continuación, cree la fuente de datos HTTP para. AWS AppSync En este ejemplo, debe realizar una llamada a AWS AppSync en la región EE. UU. Oeste (Oregón). Ajuste la siguiente configuración HTTP en un archivo denominado `http.json`, que incluye la región de la firma y el nombre del servicio:
```
{
"endpoint": "https://appsync.us-west-2.amazonaws.com/",
"authorizationConfig": {
"authorizationType": "AWS_IAM",
"awsIamConfig": {
"signingRegion": "us-west-2",
"signingServiceName": "appsync"
}
}
}
```
A continuación, utilice AWS CLI para crear la fuente de datos con un rol asociado de la siguiente manera:
```
aws appsync create-data-source --api-id \
--name AWSAppSync \
--type HTTP \
--http-config file:///http.json \
--service-role-arn
```
Cuando adjunte una resolución al campo del esquema, utilice la siguiente plantilla de mapeo de solicitudes para llamar AWS AppSync:
```
{
"version": "2018-05-29",
"method": "GET",
"resourcePath": "/v1/apis"
}
```
Cuando ejecutas una consulta GraphQL para esta fuente de datos, AWS AppSync firma la solicitud con el rol que has proporcionado e incluye la firma en la solicitud. La consulta devuelve una lista de AWS AppSync GraphQL APIs en tu cuenta en esa AWS región.