Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo di Aurora PostgreSQL con Data API in AWS AppSync

Scopri come connettere l'API GraphQL ai database Aurora PostgreSQL utilizzando. AWS AppSync Questa integrazione consente di creare applicazioni scalabili e basate sui dati eseguendo query e mutazioni SQL tramite operazioni GraphQL. AWS AppSync fornisce un'origine dati per l'esecuzione di istruzioni SQL su cluster Amazon Aurora abilitati con un'API Data. Puoi utilizzare AWS AppSync i resolver per eseguire istruzioni SQL sull'API dei dati con query, mutazioni e sottoscrizioni GraphQL.

Prima di iniziare questo tutorial, è necessario avere una conoscenza di base AWS dei servizi e dei concetti di GraphQL.

Configura il tuo database Aurora PostgreSQL

Prima di aggiungere un'origine dati Amazon RDS AWS AppSync, procedi come segue.

Verrà restituito un ARN per il cluster. Dopo aver creato un cluster, è necessario aggiungere un'istanza Serverless v2 con il comando seguente AWS CLI .

aws rds create-db-instance \
    --db-cluster-identifier appsync-tutorial \
    --db-instance-identifier appsync-tutorial-instance-1 \
    --db-instance-class db.serverless \
    --engine aurora-postgresql

Controlla lo stato del cluster con il seguente AWS CLI comando.

aws rds describe-db-clusters \
    --db-cluster-identifier appsync-tutorial \
    --query "DBClusters[0].Status"

Crea un segreto tramite la AWS Secrets Manager console o AWS CLI con un file di input come il seguente utilizzando i USERNAME e COMPLEX_PASSWORD del passaggio precedente:

{
    "username": "USERNAME",
    "password": "COMPLEX_PASSWORD"
}

Passalo come parametro a AWS CLI:

aws secretsmanager create-secret \
    --name appsync-tutorial-rds-secret \
    --secret-string file://creds.json

Verrà restituito un ARN per il segreto. Prendi nota dell'ARN del tuo cluster Aurora Serverless v2 e di Secret per dopo quando crei un'origine dati nella console. AWS AppSync

Creazione del database e della tabella

Innanzitutto, crea un database denominatoTESTDB. In PostgreSQL, un database è un contenitore che contiene tabelle e altri oggetti SQL. Verifica che il cluster Aurora Serverless v2 sia configurato correttamente prima di aggiungerlo all'API. AWS AppSync Innanzitutto, crea un database TESTDB con il parametro seguente. --sql

aws rds-data execute-statement \
    --resource-arn "arn:aws:rds:us-east-1:111122223333 ISN:cluster:appsync-tutorial" \
    --secret-arn "arn:aws:secretsmanager:us-east-1:111122223333 ISN:secret:appsync-tutorial-rds-secret" \
    --sql "create DATABASE \"testdb\"" \
    --database "postgres"

Se viene eseguito senza errori, aggiungete due tabelle con il create table comando:

 aws rds-data execute-statement \
    --resource-arn "arn:aws:rds:us-east-1:111122223333 ISN:cluster:appsync-tutorial" \
    --secret-arn "arn:aws:secretsmanager:us-east-1:111122223333 ISN:secret:appsync-tutorial-rds-secret" \
    --database "testdb" \
    --sql 'create table public.todos (id serial constraint todos_pk primary key, description text not null, due date not null, "createdAt" timestamp default now());'

aws rds-data execute-statement \
    --resource-arn "arn:aws:rds:us-east-1:111122223333 ISN:cluster:appsync-tutorial" \
    --secret-arn "arn:aws:secretsmanager:us-east-1:111122223333 ISN:secret:appsync-tutorial-rds-secret" \
    --database "testdb" \
    --sql 'create table public.tasks (id serial constraint tasks_pk primary key, description varchar, "todoId" integer not null constraint tasks_todos_id_fk references public.todos);'

In caso di successo, aggiungi il cluster come fonte di dati nell'API.

Creazione di uno schema GraphQL

Ora che la tua API dati Aurora Serverless v2 è in esecuzione con tabelle configurate, creeremo uno schema GraphQL. Puoi creare rapidamente la tua API importando le configurazioni delle tabelle da un database esistente utilizzando la procedura guidata di creazione dell'API.

Per iniziare:

Resolver per RDS

Il flusso di creazione dell'API ha creato automaticamente i resolver per interagire con i nostri tipi. Se guardi la pagina Schema, troverai dei resolver, alcuni dei seguenti resolver.

Troverai campi e resolver simili allegati per il tipo. Task Diamo un'occhiata più da vicino ad alcuni resolver.

Mutazione. CreateToDo

Dall'editor dello schema nella AWS AppSync console, sul lato destro, scegli accanto a. testdb createTodo(...): Todo Il codice del resolver utilizza la insert funzione del rds modulo per creare dinamicamente un'istruzione insert che aggiunge dati alla tabella. todos Poiché stiamo lavorando con Postgres, possiamo sfruttare l'returningistruzione per recuperare i dati inseriti.

Aggiorna il seguente resolver per specificare correttamente il tipo di campo. DATE due

import { util } from '@aws-appsync/utils';
import { insert, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input } = ctx.args;
    // if a due date is provided, cast is as `DATE`
    if (input.due) {
        input.due = typeHint.DATE(input.due)
    }
    const insertStatement = insert({
        table: 'todos',
        values: input,
        returning: '*',
    });
    return createPgStatement(insertStatement)
}

export function response(ctx) {
    const { error, result } = ctx;
    if (error) {
        return util.appendError(
            error.message,
            error.type,
            result
        )
    }
    return toJsonObject(result)[0][0]
}

Salva il resolver. Il suggerimento sul tipo contrassegna due correttamente il nostro oggetto di input come tipo. DATE Ciò consente al motore Postgres di interpretare correttamente il valore. Quindi, aggiorna lo schema per rimuovere il id CreateTodo dall'input. Poiché il nostro database Postgres può restituire l'ID generato, puoi fare affidamento su di esso per la creazione e la restituzione del risultato come una singola richiesta come segue.

input CreateTodoInput {
    due: AWSDate!
    createdAt: String
    description: String!
}

Apporta la modifica e aggiorna lo schema. Vai all'editor Queries per aggiungere un elemento al database come segue.

mutation CreateTodo {
  createTodo(input: {description: "Hello World!", due: "2023-12-31"}) {
    id
    due
    description
    createdAt
  }
}

Ottieni il seguente risultato.

{
  "data": {
    "createTodo": {
      "id": 1,
      "due": "2023-12-31",
      "description": "Hello World!",
      "createdAt": "2023-11-14 20:47:11.875428"
    }
  }
}

query.listToDos

Dall'editor dello schema nella console, sul lato destro, scegli accanto a. testdb listTodos(id: ID!): Todo Il gestore delle richieste utilizza la funzione di utilità select per creare una richiesta in modo dinamico in fase di esecuzione.

export function request(ctx) {
    const { filter = {}, limit = 100, nextToken } = ctx.args;
    const offset = nextToken ? +util.base64Decode(nextToken) : 0;
    const statement = select({
        table: 'todos',
        columns: '*',
        limit,
        offset,
        where: filter,
    });
    return createPgStatement(statement)
}

Vogliamo filtrare in todos base alla due data. Aggiorniamo il resolver per trasmettere due i valori a. DATE Aggiorna l'elenco delle importazioni e il gestore delle richieste come segue.

import { util } from '@aws-appsync/utils';
import * as rds from '@aws-appsync/utils/rds';

export function request(ctx) {
  const { filter: where = {}, limit = 100, nextToken } = ctx.args;
  const offset = nextToken ? +util.base64Decode(nextToken) : 0;

  // if `due` is used in a filter, CAST the values to DATE.
  if (where.due) {
    Object.entries(where.due).forEach(([k, v]) => {
      if (k === 'between') {
        where.due[k] = v.map((d) => rds.typeHint.DATE(d));
      } else {
        where.due[k] = rds.typeHint.DATE(v);
      }
    });
  }

  const statement = rds.select({
    table: 'todos',
    columns: '*',
    limit,
    offset,
    where,
  });
  return rds.createPgStatement(statement);
}

export function response(ctx) {
  const {
    args: { limit = 100, nextToken },
    error,
    result,
  } = ctx;
  if (error) {
    return util.appendError(error.message, error.type, result);
  }
  const offset = nextToken ? +util.base64Decode(nextToken) : 0;
  const items = rds.toJsonObject(result)[0];
  const endOfResults = items?.length < limit;
  const token = endOfResults ? null : util.base64Encode(`${offset + limit}`);
  return { items, nextToken: token };
}

Nell'editor Queries, procedi come segue.

query LIST {
  listTodos(limit: 10, filter: {due: {between: ["2021-01-01", "2025-01-02"]}}) {
    items {
      id
      due
      description
    }
  }
}

Mutation.UpdateToDo

Puoi anche un. update Todo Dall'editor di Queries, aggiorniamo il nostro primo Todo elemento di id1.

mutation UPDATE {
  updateTodo(input: {id: 1, description: "edits"}) {
    description
    due
    id
  }
}

Nota che devi specificare id l'elemento che stai aggiornando. Puoi anche specificare una condizione per aggiornare solo un elemento che soddisfa condizioni specifiche. Ad esempio, potremmo voler modificare l'elemento solo se la descrizione inizia con la edits seguente.

mutation UPDATE {
  updateTodo(input: {id: 1, description: "edits: make a change"}, condition: {description: {beginsWith: "edits"}}) {
    description
    due
    id
  }
}

Proprio come abbiamo gestito le nostre list operazioni create e, allo stesso modo, possiamo aggiornare il nostro resolver per indirizzare il due campo a. DATE Salva queste modifiche come segue. updateTodo

import { util } from '@aws-appsync/utils';
import * as rds from '@aws-appsync/utils/rds';

export function request(ctx) {
  const { input: { id, ...values }, condition = {}, } = ctx.args;
  const where = { ...condition, id: { eq: id } };

  // if `due` is used in a condition, CAST the values to DATE.
  if (condition.due) {
    Object.entries(condition.due).forEach(([k, v]) => {
      if (k === 'between') {
        condition.due[k] = v.map((d) => rds.typeHint.DATE(d));
      } else {
        condition.due[k] = rds.typeHint.DATE(v);
      }
    });
  }

  // if a due date is provided, cast is as `DATE`
  if (values.due) {
    values.due = rds.typeHint.DATE(values.due);
  }

  const updateStatement = rds.update({
    table: 'todos',
    values,
    where,
    returning: '*',
  });
  return rds.createPgStatement(updateStatement);
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    return util.appendError(error.message, error.type, result);
  }
  return rds.toJsonObject(result)[0][0];
}

Ora prova un aggiornamento con una condizione:

mutation UPDATE {
  updateTodo(
    input: {
        id: 1, description: "edits: make a change", due: "2023-12-12"},
    condition: {
        description: {beginsWith: "edits"}, due: {ge: "2023-11-08"}})
    {
          description
          due
          id
        }
}

Mutazione. deleteToDo

Puoi farlo delete con la mutazione. Todo deleteTodo Funziona come la updateTodo mutazione ed è necessario specificare id l'elemento che si desidera eliminare come segue.

mutation DELETE {
  deleteTodo(input: {id: 1}) {
    description
    due
    id
  }
}

Scrittura di interrogazioni personalizzate

Abbiamo usato le utilità del rds modulo per creare le nostre istruzioni SQL. Possiamo anche scrivere la nostra dichiarazione statica personalizzata per interagire con il nostro database. Innanzitutto, aggiorna lo schema per rimuovere il id campo dall'CreateTaskinput.

input CreateTaskInput {
    todoId: Int!
    description: String
}

Quindi, crea un paio di attività. Un'attività ha una relazione a chiave esterna con Todo la seguente.

mutation TASKS {
  a: createTask(input: {todoId: 2, description: "my first sub task"}) { id }
  b:createTask(input: {todoId: 2, description: "another sub task"}) { id }
  c: createTask(input: {todoId: 2, description: "a final sub task"}) { id }
}

Crea un nuovo campo nel tuo Query tipo chiamato getTodoAndTasks come segue.

getTodoAndTasks(id: Int!): Todo

Aggiungi un tasks campo al Todo tipo come segue.

type Todo {
    due: AWSDate!
    id: Int!
    createdAt: String
    description: String!
    tasks:TaskConnection
}

Salvare lo schema. Dall'editor di schemi nella console, sul lato destro, scegli Attach Resolver for. getTodosAndTasks(id: Int!): Todo Scegli la tua fonte di dati Amazon RDS. Aggiorna il tuo resolver con il seguente codice.

import { sql, createPgStatement,toJsonObject } from '@aws-appsync/utils/rds';

export function request(ctx) {
    return createPgStatement(
        sql`SELECT * from todos where id = ${ctx.args.id}`,
        sql`SELECT * from tasks where "todoId" = ${ctx.args.id}`);
}

export function response(ctx) {
    const result = toJsonObject(ctx.result);
    const todo = result[0][0];
    if (!todo) {
        return null;
    }
    todo.tasks = { items: result[1] };
    return todo;
}

In questo codice, utilizziamo il modello di sql tag per scrivere un'istruzione SQL a cui possiamo passare in sicurezza un valore dinamico in fase di esecuzione. createPgStatementpuò richiedere fino a due richieste SQL alla volta. Lo usiamo per inviare una richiesta per la nostra todo e un'altra per la nostratasks. Avresti potuto farlo con una JOIN dichiarazione o con qualsiasi altro metodo. L'idea è quella di poter scrivere la propria istruzione SQL per implementare la logica aziendale. Per utilizzare la query nell'editor Queries, procedi come segue.

query TodoAndTasks {
  getTodosAndTasks(id: 2) {
    id
    due
    description
    tasks {
      items {
        id
        description
      }
    }
  }
}

Eliminazione del cluster

Per eliminare il cluster:

$ aws rds delete-db-cluster \
    --db-cluster-identifier appsync-tutorial \
    --skip-final-snapshot