Tutoriel : résolveurs HTTP

Note

Nous prenons désormais principalement en charge le runtime APPSYNC_JS et sa documentation. Pensez à utiliser le runtime APPSYNC_JS et ses guides ici.

AWS AppSync vous permet d'utiliser des sources de données prises en charge (Amazon DynamoDBAWS Lambda, Amazon Service ou OpenSearch Amazon Aurora) pour effectuer diverses opérations, en plus des points de terminaison HTTP arbitraires pour résoudre les champs GraphQL. Dès que vos points de terminaison HTTP 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 une API REST (créée à l'aide d'Amazon API Gateway et Lambda) avec un point de terminaison GraphQL AWS AppSync .

Configuration en un clic

Si vous souhaitez configurer automatiquement un point de terminaison GraphQL AWS AppSync avec un point de terminaison HTTP configuré (à l'aide d'Amazon API Gateway et Lambda), vous pouvez utiliser le modèle suivant : AWS CloudFormation

Création d'une API REST

Vous pouvez utiliser le modèle AWS CloudFormation suivant pour configurer un point de terminaison REST qui fonctionne pour ce didacticiel :

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

1. Elle configure une fonction Lambda qui contient la logique métier de votre microservice.

2. Configure une API REST API Gateway avec la combinaison point de terminaison, méthode et type de contenu suivante :

Chemin de ressource API	Méthode HTTP	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 API GraphQL

Pour créer l'API GraphQL dans AWS AppSync :

• Ouvrez la console AWS AppSync et choisissez Créer une API.

• Pour le nom de l'API, saisissez UserData.

• Choisissez Schéma personnalisé.

• Sélectionnez Create (Créer).

La console AWS AppSync crée une nouvelle API GraphQL pour vous à l'aide du mode d'authentification de clé API. Vous pouvez utiliser la console pour configurer le reste de l'API GraphQL et exécuter des requêtes sur celle-ci jusqu'à la fin de ce didacticiel.

Création d'un schéma GraphQL

Maintenant que vous avez une API GraphQL, nous allons créer un schéma GraphQL. Dans l'éditeur de schéma de la console AWS AppSync , assurez-vous que votre schéma correspond au schéma ci-dessous :

schema {
    query: Query
    mutation: Mutation
}

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 de données HTTP

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

• DataSourcesDans l'onglet, choisissez Nouveau, puis tapez un nom convivial pour la source de données (par exemple,HTTP).

• Dans Type de source de données, choisissez HTTP.

• Définissez le point de terminaison sur le point de terminaison API Gateway créé. Assurez-vous de ne pas inclure le nom de l'étape dans le point de terminaison.

Remarque : à l'heure actuelle, seuls les points de terminaison publics sont pris en charge par AWS AppSync.

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

Configuration des résolveurs

Au cours de cette étape, vous allez connecter la source de données http à la requête getUser.

Pour configurer le résolveur :

• Choisissez l'onglet Schéma.

• Dans le volet Types de données à droite sous le champ Requête, recherchez le champ getUser et choisissez Joindre.

• Dans Nom de la source de données, choisissez HTTP.

• Collez le code suivant dans la section Configurer le modèle de mappage de demande :

{
    "version": "2018-05-29",
    "method": "GET",
    "params": {
        "headers": {
            "Content-Type": "application/json"
        }
    },
    "resourcePath": $util.toJson("/v1/users/${ctx.args.id}")
}

• Collez le code suivant dans la section Configurer le modèle de mappage de réponse :

## return the body
#if($ctx.result.statusCode == 200)
    ##if response is 200
    $ctx.result.body
#else
    ##if response is not 200, append the response to error block.
    $utils.appendError($ctx.result.body, "$ctx.result.statusCode")
#end

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

• Choisissez l'onglet Schéma.

• Dans le volet Types de données à droite sous le champ Mutation, recherchez le champ addUser et choisissez Joindre.

• Dans Nom de la source de données, choisissez HTTP.

• Collez le code suivant dans la section Configurer le modèle de mappage de demande :

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

• Collez le code suivant dans la section Configurer le modèle de mappage de réponse :

## Raise a GraphQL field error in case of a datasource invocation error
#if($ctx.error)
    $util.error($ctx.error.message, $ctx.error.type)
#end
## if the response status code is not 200, then return an error. Else return the body **
#if($ctx.result.statusCode == 200)
    ## If response is 200, return the body.
    $ctx.result.body
#else
    ## If response is not 200, append the response to error block.
    $utils.appendError($ctx.result.body, "$ctx.result.statusCode")
#end

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

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

Cela doit renvoyer la réponse suivante :

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

Invoquer AWS des services

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

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

• Un rôle IAM autorisé à appeler les API du AWS service

• La configuration de signature dans la source de données

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

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

Créez ensuite la source de données HTTP pour AWS AppSync. Dans cet exemple, vous appelez AWS AppSync dans la région USA Ouest (Oregon). Configurez la configuration HTTP 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 dans le schéma, utilisez le modèle de mappage de demande 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, AWS AppSync signe la demande à l'aide du rôle que vous avez fourni et inclut la signature dans la demande. La requête renvoie une liste des API AWS AppSync GraphQL présentes dans votre compte dans cette AWS région.