Création d'un REST API Création de votre GraphQL API Création d'un schéma GraphQL Configurez votre source HTTP de données Configuration des résolveurs Invoquer AWS des services

Utilisation de HTTP résolveurs dans AWS AppSync

AWS AppSync vous permet d'utiliser des sources de données prises en charge (Amazon DynamoDB AWS Lambda, Amazon Service HTTP ou OpenSearch Amazon Aurora) pour effectuer diverses opérations, en plus des points de terminaison arbitraires pour résoudre les champs GraphQL. Une fois que vos HTTP points de terminaison sont disponibles, vous pouvez vous y connecter à l'aide d'une source de données. Ensuite, vous pouvez configurer un résolveur dans le schéma GraphQL pour effectuer des opérations telles que des requêtes, des mutations et des abonnements. Ce didacticiel vous présente certains exemples courants.

Dans ce didacticiel, vous utiliserez un REST API (créé à l'aide d'Amazon API Gateway et Lambda) avec un point de terminaison GraphQL AWS AppSync .

Création d'un REST API

Vous pouvez utiliser le AWS CloudFormation modèle suivant pour configurer un REST point de terminaison adapté à ce didacticiel :

La AWS CloudFormation pile exécute les étapes suivantes :

Elle configure une fonction Lambda qui contient la logique métier de votre microservice.
Configure une API passerelle REST API avec la combinaison endpoint/method/content de types suivante :

APIParcours des ressources	HTTPMéthode	Type de contenu pris en charge
/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

Création de votre GraphQL API

Pour créer le GraphQL API dans : AWS AppSync

Ouvrez la AWS AppSync console et choisissez Create API.
Choisissez GraphQL, APIs puis choisissez Design from scratch. Choisissez Suivant.
Pour le API nom, tapezUserData. Choisissez Suivant.
Sélectionnez Create GraphQL resources later. Choisissez Suivant.
Passez en revue vos entrées et choisissez Créer API.

La AWS AppSync console crée un nouveau GraphQL API pour vous en utilisant le mode d'authentification par API clé. Vous pouvez utiliser la console pour configurer davantage votre GraphQL API et exécuter des requêtes.

Création d'un schéma GraphQL

Maintenant que vous avez un GraphQLAPI, créons un schéma GraphQL. Dans l'éditeur de schéma de la AWS AppSync console, utilisez l'extrait ci-dessous :


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
}

Configurez votre source HTTP de données

Pour configurer votre source de HTTP données, procédez comme suit :

Sur la page Sources de données de votre AWS AppSync GraphQLAPI, choisissez Create data source.
Entrez un nom pour la source de données, par exempleHTTP_Example.
Dans Type de source de données, choisissez HTTPpoint de terminaison.
Définissez le point de terminaison sur le point de terminaison API Gateway créé au début du didacticiel. Vous pouvez trouver votre point de terminaison généré par une pile en accédant à la console Lambda et en trouvant votre application sous Applications. Dans les paramètres de votre application, vous devriez voir un APIpoint de terminaison qui sera votre point de terminaison AWS AppSync. Assurez-vous de ne pas inclure le nom de l'étape dans le point de terminaison. Par exemple, si votre point de terminaison l'étaithttps://aaabbbcccd.execute-api.us-east-1.amazonaws.com/v1, vous le saisiriezhttps://aaabbbcccd.execute-api.us-east-1.amazonaws.com.

Note

Pour le moment, seuls les points de terminaison publics sont pris en charge par AWS AppSync.

Pour plus d'informations sur les autorités de certification reconnues par le AWS AppSync service, consultez la section Autorités de certification (CA) reconnues par AWS AppSync pour les points de HTTPS terminaison.

Configuration des résolveurs

Au cours de cette étape, vous allez connecter la source de HTTP données aux addUser requêtes getUser et.

Pour configurer le getUser résolveur, procédez comme suit :

Dans votre AWS AppSync GraphQLAPI, choisissez l'onglet Schéma.
À droite de l'éditeur de schéma, dans le volet Résolveurs et sous le type de requête, recherchez le getUser champ et choisissez Attacher.
Conservez le type de résolveur à Unit et le moteur d'exécution àAPPSYNC_JS.
Dans Nom de la source de données, choisissez le HTTP point de terminaison que vous avez créé précédemment.
Sélectionnez Create (Créer).

Dans l'éditeur de code Resolver, ajoutez l'extrait suivant en tant que gestionnaire de requêtes :


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}`,
	}
}

Ajoutez l'extrait suivant en tant que gestionnaire de réponses :


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)
}

Choisissez l'onglet Requête et exécutez la requête suivante :


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

Cela doit renvoyer la réponse suivante :


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

Pour configurer le addUser résolveur, procédez comme suit :

Choisissez l'onglet Schéma.
À droite de l'éditeur de schéma, dans le volet Résolveurs et sous le type de requête, recherchez le addUser champ et choisissez Attacher.
Conservez le type de résolveur à Unit et le moteur d'exécution àAPPSYNC_JS.
Dans Nom de la source de données, choisissez le HTTP point de terminaison que vous avez créé précédemment.
Sélectionnez Create (Créer).

Dans l'éditeur de code Resolver, ajoutez l'extrait suivant en tant que gestionnaire de requêtes :


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

Ajoutez l'extrait suivant en tant que gestionnaire de réponses :


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")
    }
}

Choisissez l'onglet Requête et exécutez la requête suivante :


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

Si vous réexécutez la getUser requête, elle devrait renvoyer la réponse suivante :


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

Invoquer AWS des services

Vous pouvez utiliser des HTTP résolveurs pour configurer une interface API AWS GraphQL pour les services. HTTPles demandes AWS doivent être signées selon le processus Signature Version 4 afin de AWS pouvoir identifier leur expéditeur. AWS AppSync calcule la signature en votre nom lorsque vous associez un IAM rôle à la source de HTTP données.

Vous fournissez deux composants supplémentaires pour appeler des AWS services avec des HTTP résolveurs :

Un IAM rôle autorisé à appeler le AWS service APIs
La configuration de signature dans la source de données

Par exemple, si vous souhaitez appeler l'ListGraphqlApis opération avec des HTTP résolveurs, vous devez d'abord créer un IAM rôle qui AWS AppSync suppose que la politique suivante est attachée :


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

Créez ensuite la source HTTP de données pour AWS AppSync. Dans cet exemple, vous appelez AWS AppSync dans la région USA Ouest (Oregon). Configurez la HTTP configuration suivante dans un fichier nomméhttp.json, qui inclut la région de signature et le nom du service :


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

Utilisez ensuite le AWS CLI pour créer la source de données avec un rôle associé, comme suit :


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

Lorsque vous attachez un résolveur au champ du schéma, utilisez le modèle de mappage de demandes suivant pour appeler AWS AppSync :


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

Lorsque vous exécutez une requête GraphQL pour cette source de données, signez la AWS AppSync demande en utilisant le rôle que vous avez indiqué et incluez la signature dans la demande. La requête renvoie une liste de AWS AppSync GraphQL présents APIs dans votre compte dans cette AWS région.

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

Utilisation des opérations par lots DynamoDB

Utilisation d'Aurora Postgre SQL avec des données API