Utilizzo AWS Lambda con Amazon Aurora DSQL

Accedi a AWS Management Console e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

Scegli Crea funzione.

Fornisci un nome, ad esempiodsql-sample.

Non modificare le impostazioni predefinite per assicurarti che Lambda crei un nuovo ruolo con autorizzazioni Lambda di base.

Scegli Crea funzione.

Nella tua funzione Lambda, scegli Configurazione > Autorizzazioni.

Scegli il nome del ruolo per aprire il ruolo di esecuzione nella console IAM.

Scegli Aggiungi autorizzazioni > Crea policy in linea e usa l'editor JSON.

In Action incolla la seguente azione per autorizzare la tua identità IAM a connettersi utilizzando il ruolo del database di amministrazione.

"Action": ["dsql:DbConnectAdmin"],

In Resource, aggiungi l'Amazon Resource Name (ARN) del tuo cluster. Puoi anche usare un jolly.

"Resource": ["*"]

Scegli Next (Successivo).

Inserisci un nome per la politica, ad esempiodsql-sample-dbconnect.

Scegliere Create Policy (Crea policy).

Crea una cartella denominatamyfunction.

Nella cartella, crea un nuovo file denominato package.json con il seguente contenuto.

{
  "dependencies": {
    "@aws-sdk/core": "^3.587.0",
    "@aws-sdk/credential-providers": "^3.587.0",
    "@smithy/protocol-http": "^4.0.0",
    "@smithy/signature-v4": "^3.0.0",
    "pg": "^8.11.5"
  }
}

Nella cartella, create un file denominato index.mjs nella directory con il seguente contenuto.

import { formatUrl } from "@aws-sdk/util-format-url";
import { HttpRequest } from "@smithy/protocol-http";
import { SignatureV4 } from "@smithy/signature-v4";
import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
import { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS } from "@smithy/config-resolver";
import { Hash } from "@smithy/hash-node";
import { loadConfig } from "@smithy/node-config-provider";
import pg from "pg";
const { Client } = pg;

export const getRuntimeConfig = (config) => {
  return {
    runtime: "node",
    sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
    credentials: config?.credentials ?? fromNodeProviderChain(),
    region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS),
    ...config,
  };
};

// Aurora DSQL requires IAM authentication
// This class generates auth tokens signed using AWS Signature Version 4
export class Signer {
  constructor(hostname) {
    const runtimeConfiguration = getRuntimeConfig({});

    this.credentials = runtimeConfiguration.credentials;
    this.hostname = hostname;
    this.region = runtimeConfiguration.region;

    this.sha256 = runtimeConfiguration.sha256;
    this.service = "dsql";
    this.protocol = "https:";
  }
  
  async getAuthToken() {
    const signer = new SignatureV4({
      service: this.service,
      region: this.region,
      credentials: this.credentials,
      sha256: this.sha256,
    });

    // To connect with a custom database role, set Action as "DbConnect"
    const request = new HttpRequest({
      method: "GET",
      protocol: this.protocol,
      hostname: this.hostname,
      query: {
        Action: "DbConnectAdmin",
      },
      headers: {
        host: this.hostname,
      },
    });

    const presigned = await signer.presign(request, {
      expiresIn: 3600,
    });

    // RDS requires the scheme to be removed
    // https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.Connecting.html
    return formatUrl(presigned).replace(`${this.protocol}//`, "");
  }
}

// To connect with a custom database role, set user as the database role name
async function dsql_sample(token, endpoint) {
  const client = new Client({
    user: "admin",
    database: "postgres",
    host: endpoint,
    password: token,
    ssl: { 
      rejectUnauthorized: false
    },
  });

  await client.connect();
  console.log("[dsql_sample] connected to Aurora DSQL!");

  try {
    console.log("[dsql_sample] attempting transaction.");
    await client.query("BEGIN; SELECT txid_current_if_assigned(); COMMIT;");
    return 200;
  } catch (err) {
    console.log("[dsql_sample] transaction attempt failed!");
    console.error(err);
    return 500;
  } finally {
    await client.end();
  }
}

// https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html
export const handler = async (event) => {
  const endpoint = event.endpoint;
  const s = new Signer(endpoint);
  const token = await s.getAuthToken();
  const responseCode = await dsql_sample(token, endpoint);
  
  const response = {
    statusCode: responseCode,
    endpoint: endpoint,
  };
  return response;
};

Utilizzate i seguenti comandi per creare un pacchetto.

npm install
zip -r pkg.zip .

Nella scheda Codice della funzione Lambda, scegli Carica da > .zip file

Carica il file che pkg.zip hai creato. Per ulteriori informazioni, consulta Distribuire le funzioni Lambda di Node.js con archivi di file.zip.

Nella scheda Test della funzione Lambda, incolla il seguente payload JSON e modificalo per utilizzare l'ID del cluster.

Nella scheda Test della funzione Lambda, usa il seguente Event JSON modificato per specificare l'endpoint del cluster.

{"endpoint": "replace_with_your_cluster_endpoint"}

Inserisci il nome di un evento, ad esempio. dsql-sample-test Scegli Save (Salva).

Scegli Test (Esegui test).

Scegliete Dettagli per espandere la risposta di esecuzione e l'output del registro.

Se ha avuto successo, la risposta all'esecuzione della funzione Lambda dovrebbe restituire un codice di stato 200:

{statusCode": 200, "endpoint": "your_cluster_endpoint"}

Se il database restituisce un errore o se la connessione al database fallisce, la risposta di esecuzione della funzione Lambda restituisce un codice di stato 500.

{"statusCode": 500,"endpoint": "your_cluster_endpoint"}