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à.

Amazon Aurora PostgreSQLfunzioni definite dall'utente per Amazon Location Service

Puoi utilizzare Amazon Location Service per lavorare con coordinate e indirizzi memorizzati nelle tabelle del database per pulire e arricchire i tuoi dati geospaziali.

Per esempio:

Questo tutorial mostra come formattare e arricchire gli indirizzi memorizzati in una tabella di Amazon Aurora PostgreSQL database utilizzando Amazon Location Service.

Il codice di esempio è disponibile nell'archivio di esempi di Amazon Location Service su GitHub, che include un AWS CloudFormation modello.

Panoramica

L'architettura prevede le seguenti integrazioni:

Prerequisiti

Prima di iniziare, sono necessari i seguenti prerequisiti:

Avvio rapido

In alternativa ai passaggi descritti in questo tutorial, puoi avviare uno stack rapido per implementare una AWS Lambda funzione che supporti il funzionamento di Amazon Location. SearchPlaceIndexForText Questo configura automaticamente il tuo AWS account per consentire ad Amazon Aurora di effettuare chiamate. AWS Lambda

Una volta configurato il tuo AWS account, dovrai:

Crea una risorsa per l'indice dei luoghi

Inizia creando una risorsa per l'indice dei luoghi per supportare le query di geocodifica.

Crea una AWS Lambda funzione per la geocodifica

Per creare una connessione tra Amazon Location Service Amazon Aurora PostgreSQL e Amazon, è necessaria una AWS Lambda funzione per gestire le richieste dal motore di database. Questa funzione traduce l'evento della funzione Lambda definita dall'utente e chiama l'operazione Amazon Location. SearchPlaceIndexForText

Puoi creare la funzione utilizzando la AWS Lambda console, le o le AWS Command Line Interface API. AWS Lambda

Per creare una funzione Lambda definita dall'utente utilizzando la console

Concedi Amazon Aurora PostgreSQL l'accesso a AWS Lambda

Prima di Amazon Aurora PostgreSQL poter richiamare una AWS Lambda funzione, è necessario concedere l'autorizzazione di accesso.

Se il tuo Amazon Aurora PostgreSQL cluster non è accessibile pubblicamente, dovrai prima creare un endpoint VPC per Amazon Aurora per AWS Lambda chiamare la tua funzione Lambda.

Crea un endpoint VPC per AWS Lambda

Crea una policy IAM per concedere l'autorizzazione a richiamare la tua funzione AWS Lambda

Crea un ruolo IAM per concedere l'autorizzazione ad Amazon Relational Database Service (Amazon RDS)

Creando un ruolo IAM, Amazon Aurora PostgreSQL puoi assumere il ruolo per tuo conto per accedere alla tua funzione Lambda. Per ulteriori informazioni, consulta la pagina relativa alla creazione di un ruolo per delegare le autorizzazioni a un utente IAM nella Guida per l'utente IAM.

L'esempio seguente è un AWS CLI comando che crea un ruolo denominato AuroraGeocoderInvokeRole:

aws iam create-role  --role-name rds-lambda-role --assume-role-policy-document '{
    "Version": "2012-10-17",
    "Statement": [
        {
        "Effect": "Allow",
        "Principal": {
            "Service": "rds.amazonaws.com"
        },
        "Action": "sts:AssumeRole"
        }
    ] 
}'

Collega la tua policy IAM al ruolo IAM

Se hai un ruolo IAM, collega la policy IAM che hai creato.

L'esempio seguente è un AWS CLI comando che collega la policy AuroraGeocoderInvokeal ruolo AuroraGeocoderInvokeRole.

aws iam attach-role-policy  --policy-arn AuroraGeocoderInvoke  --role-name AuroraGeocoderInvokeRole

Aggiungi il ruolo IAM a un cluster Amazon Aurora DB

L'esempio seguente è un AWS CLI comando per aggiungere un ruolo IAM a un cluster Amazon Aurora PostgreSQL DB denominato MyAuroraCluster.

aws rds add-role-to-db-cluster \
--db-cluster-identifier MyAuroraCluster \
--feature-name Lambda \
--role-arn AuroraGeocoderInvokeRole   \
--region your-region

Richiama la funzione AWS Lambda

Dopo aver concesso l'autorizzazione Amazon Aurora PostgreSQL a richiamare la funzione Lambda di geocodifica, puoi creare Amazon Aurora PostgreSQL una funzione definita dall'utente per richiamare la funzione di geocodifica. AWS Lambda Per ulteriori informazioni, consulta Invocare una AWS Lambda funzione da un cluster Amazon Aurora PostgreSQL DB nella Guida per l'utente di Amazon Aurora.

Installa le estensioni PostgreSQL richieste

Per installare le estensioni aws _commons e le aws_lambda estensioni PostgreSQL richieste, consulta Panoramica sull'uso di una funzione Lambda nella Guida per l'utente di Amazon Aurora.

CREATE EXTENSION IF NOT EXISTS aws_lambda CASCADE;

Installa le estensioni PostGIS richieste

PostGIS è un'estensione di PostgreSQL per l'archiviazione e la gestione delle informazioni spaziali. Per ulteriori informazioni, consulta Working with the PostGIS nella Amazon Relational Database Service User Guide.

CREATE EXTENSION IF NOT EXISTS postgis;

Creare una funzione SQL definita dall'utente che richiami la funzione Lambda

In un editor SQL, crea una nuova funzione definita dall'utente per richiamare la funzionef_SearchPlaceIndexForText: AuroraGeocoder

CREATE OR REPLACE FUNCTION f_SearchPlaceIndexForText(
  text text,
  bias_position geometry(Point, 4326) DEFAULT NULL,
  filter_bbox box2d DEFAULT NULL,
  filter_countries text[] DEFAULT NULL,
  max_results int DEFAULT 1
)
 RETURNS TABLE (
   label text,
   address_number text,
   street text,
   municipality text,
   postal_code text,
   sub_region text,
   region text,
   country text,
   geom geometry(Point, 4326)
 )
 LANGUAGE plpgsql
 IMMUTABLE
AS $function$
begin
    RETURN QUERY
    WITH results AS (
      SELECT json_array_elements(payload) rsp
      FROM aws_lambda.invoke(
        aws_commons.create_lambda_function_arn('AuroraGeocoder'),
        json_build_object(
          'text', text,
          'biasPosition',
          CASE WHEN bias_position IS NOT NULL THEN
            array_to_json(ARRAY[ST_X(bias_position), ST_Y(bias_position)])
          END,
          'filterBBox',
          CASE WHEN filter_bbox IS NOT NULL THEN
            array_to_json(ARRAY[ST_XMin(filter_bbox), ST_YMin(filter_bbox), ST_XMax(filter_bbox), ST_YMax(filter_bbox)])
          END,
          'filterCountries', filter_countries,
          'maxResults', max_results
        )
      )
    )
    SELECT
      rsp->'Place'->>'Label' AS label,
      rsp->'Place'->>'AddressNumber' AS address_number,
      rsp->'Place'->>'Street' AS street,
      rsp->'Place'->>'Municipality' AS municipality,
      rsp->'Place'->>'PostalCode' AS postal_code,
      rsp->'Place'->>'SubRegion' AS sub_region,
      rsp->'Place'->>'Region' AS region,
      rsp->'Place'->>'Country' AS country,
      ST_GeomFromGeoJSON(
        json_build_object(
          'type', 'Point',
            'coordinates', rsp->'Place'->'Geometry'->'Point'
        )
      ) geom
    FROM results;
end;
$function$;

Chiama la funzione SQL per la geocodifica da Aurora

L'esecuzione dell'istruzione SQL richiama la funzione Lambda AuroraGeocoder, che prende i record di indirizzi dalla tabella del database nel Amazon Aurora PostgreSQL database e li geocodifica utilizzando una risorsa di indice dei luoghi.

La seguente funzione f_SearchPlaceIndexForText SQL effettua richieste all'SearchPlaceIndexForTextAPI di Amazon Location tramite la funzione AuroraGeocoderLambda. La funzione restituisce una geom colonna che è una geometria PostGIS, ST_AsText(geom) che viene convertita in testo.

SELECT *, ST_AsText(geom)
FROM f_SearchPlaceIndexForText('Vancouver, BC');

Per impostazione predefinita, il valore restituito conterrà una riga. Per richiedere righe aggiuntive, fino al MaxResults limite, esegui la seguente istruzione SQL fornendo un elenco dei risultati (BiasPositione limitandolo ai risultati) in Canada.

SELECT *
FROM f_SearchPlaceIndexForText('Mount Pleasant', ST_MakePoint(-123.113, 49.260), null, '{"CAN"}', 5);

Per filtrare i risultati utilizzando un riquadro di selezione, passa a comeBox2D: filter_bbox

SELECT *
FROM f_SearchPlaceIndexForText('Mount Pleasant', null, 'BOX(-139.06 48.30, -114.03 60.00)'::box2d, '{"CAN"}', 5);

Per ulteriori informazioni sui tipi e le funzioni di PostGIS, consultate PostGIS Reference.

Arricchimento di un database contenente dati di indirizzo

Puoi creare un indirizzo formattato e contemporaneamente normalizzarlo e geocodificarlo utilizzando l'operazione Amazon Location, SearchPlaceIndexForText fornita da una tabella di database con i seguenti dati suddivisi nelle seguenti colonne:

WITH source_data AS (
  SELECT
    id,
    address || ', ' || city || ', ' || state || ', ' || zip AS formatted_address
  FROM addresses
),
geocoded_data AS (
  SELECT
    *,
    (f_SearchPlaceIndexForText(formatted_address)).*
  FROM source_data
)
SELECT
  id,
  formatted_address,
  label normalized_address,
  ST_Y(geom) latitude,
  ST_X(geom) longitude
FROM geocoded_data
-- limit the number of rows that will be geocoded; remove this to geocode the entire table
LIMIT 1;

L'esempio seguente illustra una riga della tabella databile risultante:

 id |      formatted_address         |            normalized_address              |     latitude     |     longitude
----+--------------------------------+--------------------------------------------+------------------+-------------------
 42 | 123 Anytown Ave N, Seattle, WA | 123 Anytown Ave N, Seattle, WA, 12345, USA | 47.6223000127926 | -122.336745971039
(1 row)

Aggiorna la tabella del database e compila le colonne

L'esempio seguente aggiorna la tabella e popola le colonne con i risultati delle SearchPlaceIndexForText query:

WITH source_data AS (
  -- select rows that have not been geocoded and created a formatted address for each
  SELECT
    id,
    address || ', ' || city || ', ' || state || ', ' || zip AS formatted_address
  FROM addresses
  WHERE label IS NULL
  -- limit the number of rows that will be geocoded; remove this to geocode the entire table
  LIMIT 1
),
geocoded_data AS (
  -- geocode each row and keep it linked to the source's ID
  SELECT
    id,
    (f_SearchPlaceIndexForText(formatted_address)).*
  FROM source_data
)
UPDATE addresses
-- populate columns
SET
  normalized_address = geocoded_data.label,
  latitude = ST_Y(geocoded_data.geom),
  longitude = ST_X(geocoded_data.geom)
FROM geocoded_data
-- ensure that rows match
WHERE addresses.id = geocoded_data.id;

Passaggi successivi

Il codice di esempio è disponibile nell'archivio di esempi di Amazon Location Service su GitHub, che include un AWS CloudFormation modello.