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 SQL Postgre con Data in API AWS AppSync

AWS AppSync fornisce una fonte di dati per l'esecuzione di SQL istruzioni su cluster Amazon Aurora abilitati con un Data. API Puoi utilizzare i AWS AppSync resolver per eseguire SQL istruzioni sui dati con query, mutazioni e API sottoscrizioni GraphQL.

Creazione di cluster

Prima di aggiungere un'origine RDS dati Amazon AWS AppSync, abilita un cluster Data API on a Aurora Serverless. È inoltre necessario configurare un segreto utilizzando. AWS Secrets Manager Per creare un cluster Aurora Serverless, puoi utilizzare: AWS CLI

aws rds create-db-cluster \
    --db-cluster-identifier appsync-tutorial \
    --engine aurora-postgresql --engine-version 13.11 \
    --engine-mode serverless \
    --master-username USERNAME \
    --master-user-password COMPLEX_PASSWORD

Ciò restituirà un valore ARN per il cluster. Puoi controllare lo stato del tuo cluster con il 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 il USERNAME e COMPLEX_PASSWORD del passaggio precedente:

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

Passalo come parametro aCLI:

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

Questo restituirà un valore ARN per il segreto. Prendi nota ARN del tuo cluster Aurora Serverless e di Secret per dopo quando crei un'origine dati nella console. AWS AppSync

Abilitazione dei dati API

Una volta modificato lo stato del clusteravailable, abilita i dati API seguendo la RDSdocumentazione di Amazon. I dati API devono essere abilitati prima di aggiungerli come fonte di AWS AppSync dati. Puoi anche abilitare i dati API utilizzando AWS CLI:

aws rds modify-db-cluster \
    --db-cluster-identifier appsync-tutorial \
    --enable-http-endpoint \
    --apply-immediately

Creazione del database e della tabella

Dopo aver abilitato i tuoi datiAPI, verifica che funzioni utilizzando il aws rds-data execute-statement comando in. AWS CLI Ciò garantisce che il cluster Aurora Serverless sia configurato correttamente prima di aggiungerlo a. AWS AppSync API Innanzitutto, crea un TESTDBdatabase con il --sql parametro:

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

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:123456789012:cluster:appsync-tutorial" \
    --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012: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:123456789012:cluster:appsync-tutorial" \
    --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012: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);'

Se tutto funziona senza problemi, ora puoi aggiungere il cluster come fonte di dati nel tuoAPI.

Creazione di uno schema GraphQL

Ora che Aurora Serverless Data API è in esecuzione con tabelle configurate, creeremo uno schema GraphQL. Puoi farlo manualmente, ma ti AWS AppSync consente di iniziare rapidamente importando la configurazione delle tabelle da un database esistente utilizzando la procedura guidata di creazione. API

Per iniziare:

Risolutori per RDS

Il flusso API di creazione ha creato automaticamente i resolver per interagire con i nostri tipi. Se guardi la pagina Schema, troverai i resolver necessari per:

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 testdb accanto acreateTodo(...): 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.

Aggiorniamo il 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, possiamo fare affidamento su di esso per la creazione e la restituzione del risultato come singola richiesta:

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:

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

Ottieni il risultato:

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

Interrogazione. listTodos

Dall'editor dello schema nella console, sul lato destro, scegli testdb accanto alistTodos(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:

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

Proviamo la query. Nell'editor delle interrogazioni:

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

Mutazione. updateTodo

Puoi anche update unTodo. 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 conedits:

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 passare il due campo a. DATE Salva queste modifiche in: 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 Todo con la deleteTodo mutazione. Funziona come la updateTodo mutazione e devi specificare id l'elemento che desideri eliminare:

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

Scrivere interrogazioni personalizzate

Abbiamo usato le utilità del rds modulo per creare le nostre SQL dichiarazioni. 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 conTodo:

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

getTodoAndTasks(id: Int!): Todo

Aggiungi un tasks campo al Todo tipo:

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 RDS dati Amazon. 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'SQListruzione a cui possiamo passare in sicurezza un valore dinamico in fase di esecuzione. createPgStatementpuò richiedere fino a due SQL richieste 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 SQL dichiarazione per implementare la propria logica aziendale. Per usare la query nell'editor Queries, possiamo provare questo:

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