Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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 .

Configuration en un clic

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

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 :

Création de votre GraphQL API

Pour créer le GraphQL API dans : AWS AppSync

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 le reste de GraphQL API et exécuter des requêtes dessus pour le reste de ce didacticiel.

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, assurez-vous que votre schéma correspond au schéma suivant :

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

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

Remarque : Pour le moment, 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 HTTPS terminaison.

Configuration des résolveurs

Au cours de cette étape, vous connectez la source de données HTTP à la getUserrequête.

Pour configurer le résolveur :

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

## 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

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

Cela doit renvoyer la réponse suivante :

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

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

## 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

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 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 :

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.