Creare un REST API Creare il tuo GraphQL API Creazione di uno schema GraphQL Configura la tua fonte di dati HTTP Configurazione dei resolver Invocare AWS i servizi

Utilizzo dei HTTP resolver in AWS AppSync

AWS AppSync consente di utilizzare fonti di dati supportate (ad esempio Amazon DynamoDB AWS Lambda, Amazon Service o OpenSearch Amazon Aurora) per eseguire varie operazioni, oltre a qualsiasi endpoint HTTP arbitrario per risolvere i campi GraphQL. Una volta che gli HTTP endpoint sono disponibili, puoi connetterti ad essi utilizzando una fonte di dati. Quindi, è possibile configurare un resolver nello schema per eseguire operazioni GraphQL, ad esempio query, mutazioni e sottoscrizioni. Questo tutorial fornirà una guida di alcuni esempi comuni.

In questo tutorial utilizzi un REST API (creato utilizzando Amazon API Gateway e Lambda) con un endpoint GraphQL AWS AppSync .

Creare un REST API

Puoi usare il seguente AWS CloudFormation modello per configurare un REST endpoint che funzioni per questo tutorial:

Lo AWS CloudFormation stack esegue i seguenti passaggi:

Imposta una funzione Lambda che contiene la logica di business per il tuo microservizio.
Configura un API gateway REST API con la seguente combinazione endpoint/method/content di tipi:

APIPercorso delle risorse	HTTPMetodo	Tipo di contenuto supportato
/v1/utenti	POST	application/json
/v1/utenti	GET	application/json
/v1/utenti/1	GET	application/json
/v1/utenti/1	PUT	application/json
/v1/utenti/1	DELETE	application/json

Creare il tuo GraphQL API

Per creare il GraphQL API in: AWS AppSync

Apri la AWS AppSync console e scegli Crea API.
Scegli GraphQL APIs e poi scegli Design da zero. Scegli Next (Successivo).
Per il API nome, digitateUserData. Scegli Next (Successivo).
Scegli Create GraphQL resources later. Scegli Next (Successivo).
Controlla i dati inseriti e scegli Crea API.

La AWS AppSync console crea un nuovo GraphQL API per te utilizzando la modalità di autenticazione con API chiave. Puoi usare la console per configurare ulteriormente GraphQL API ed eseguire le richieste.

Creazione di uno schema GraphQL

Ora che hai un GraphQLAPI, creiamo uno schema GraphQL. Nell'editor di schema della AWS AppSync console, usa lo snippet seguente:


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
}

Configura la tua fonte di dati HTTP

Per configurare l'origine HTTP dati, procedi come segue:

Nella pagina Sorgenti dati di AWS AppSync GraphQLAPI, scegli Crea origine dati.
Inserisci un nome per la fonte di dati, ad esempioHTTP_Example.
In Tipo di origine dati, scegli HTTPendpoint.
Imposta l'endpoint sull'endpoint API Gateway creato all'inizio del tutorial. Puoi trovare l'endpoint generato dallo stack accedendo alla console Lambda e trovando l'applicazione in Applicazioni. All'interno delle impostazioni dell'applicazione, dovresti vedere un APIendpoint che fungerà da endpoint. AWS AppSync Assicurati di non includere il nome dello stage come parte dell'endpoint. Ad esempio, se il tuo endpoint lo fossehttps://aaabbbcccd.execute-api.us-east-1.amazonaws.com/v1, dovresti digitare. https://aaabbbcccd.execute-api.us-east-1.amazonaws.com

Nota

Al momento, solo gli endpoint pubblici sono supportati da. AWS AppSync

Per ulteriori informazioni sulle autorità di certificazione riconosciute dal AWS AppSync servizio, consulta Certificate Authorities (CA) Recognized by AWS AppSync for HTTPS Endpoints.

Configurazione dei resolver

In questo passaggio, collegherai l'origine HTTP dati alle query getUser eaddUser.

Per configurare il getUser resolver:

Nel tuo AWS AppSync GraphQLAPI, scegli la scheda Schema.
A destra dell'editor dello schema, nel riquadro Resolvers e sotto il tipo di query, trova il getUser campo e scegli Allega.
Mantieni invariato il tipo di resolver e il runtime inalteratoUnit. APPSYNC_JS
Nel Nome dell'origine dati, scegli l'HTTPendpoint creato in precedenza.
Scegli Create (Crea) .

Nell'editor di codice Resolver, aggiungi il seguente frammento come gestore delle richieste:


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

Aggiungi il seguente frammento come gestore delle risposte:


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

Scegliere la scheda Query quindi eseguire la seguente query:


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

Viene restituita la risposta seguente:


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

Per configurare il resolver: addUser

Scegli la scheda Schema.
A destra dell'editor dello schema, nel riquadro Resolver e sotto il tipo di query, trova il addUser campo e scegli Allega.
Mantieni invariato il tipo di resolver e il runtime inalteratoUnit. APPSYNC_JS
Nel Nome dell'origine dati, scegli l'HTTPendpoint creato in precedenza.
Scegli Create (Crea) .

Nell'editor di codice Resolver, aggiungi il seguente frammento come gestore delle richieste:


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

Aggiungi il seguente frammento come gestore delle risposte:


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

Scegliere la scheda Query quindi eseguire la seguente query:


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

Se esegui nuovamente la getUser query, dovrebbe restituire la seguente risposta:


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

Invocare AWS i servizi

È possibile utilizzare HTTP i resolver per configurare un'interfaccia GraphQL per i servizi. API AWS HTTPle richieste AWS devono essere firmate con il processo Signature Version 4 in modo da AWS poter identificare chi le ha inviate. AWS AppSync calcola la firma per tuo conto quando associ un IAM ruolo alla fonte di HTTP dati.

Fornisci due componenti aggiuntivi per richiamare i AWS servizi con HTTP resolver:

Un IAM ruolo con le autorizzazioni per chiamare il servizio AWS APIs
Configurazione della firma nell'origine dati

Ad esempio, se si desidera chiamare l'ListGraphqlApis operazione con HTTP resolver, è necessario innanzitutto creare un IAM ruolo che AWS AppSync presuppone la seguente politica allegata:


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

Quindi, create la fonte di dati per. HTTP AWS AppSync In questo esempio, si chiama la AWS AppSync regione Stati Uniti occidentali (Oregon). Imposta la seguente HTTP configurazione in un file denominatohttp.json, che include la regione di firma e il nome del servizio:


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

Quindi, utilizzate il AWS CLI per creare l'origine dati con un ruolo associato come segue:


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

Quando colleghi un resolver al campo dello schema, usa il seguente modello di mappatura delle richieste per chiamare: AWS AppSync


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

Quando esegui una query GraphQL per questa fonte di dati, AWS AppSync firma la richiesta utilizzando il ruolo che hai fornito e include la firma nella richiesta. La query restituisce un elenco di AWS AppSync GraphQL APIs nel tuo account in quella AWS regione.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo delle operazioni batch di DynamoDB

Usare Aurora SQL Postgre con i dati API