Amazon Aurora PostgreSQL Benutzerdefinierte Funktionen für Amazon Location Service

Sie können Amazon Location Service verwenden, um mit Koordinaten und Adressen zu arbeiten, die in Datenbanktabellen gespeichert sind, um Ihre Geodaten zu bereinigen und zu ergänzen.

Beispielsweise:

• Sie können Geokodierung verwenden, um Adressen in Koordinaten zu konvertieren, um Datenlücken für Adressen zu normalisieren und zu füllen, die in einer Datenbanktabelle gespeichert sind.

• Sie können Adressen geocodieren, um ihre Positionen zu erhalten, und die Koordinaten mit räumlichen Datenbankfunktionen verwenden, z. B. mit einer Funktion, die Zeilen in einem bestimmten Bereich anzeigt.

• Sie können mit erweiterten Daten automatisierte Berichte erstellen, z. B. einen automatisierten Bericht, der alle Geräte in einem bestimmten Bereich veranschaulicht, oder einen automatisierten Bericht für Machine Learning, der Bereiche mit höheren Fehlerraten beim Senden von Standortaktualisierungen veranschaulicht.

Dieses Tutorial zeigt, wie Adressen formatiert und anreichert werden, die in einer -Amazon Aurora PostgreSQLDatenbanktabelle mit Amazon Location Service gespeichert sind.

• Amazon Aurora PostgreSQL – Eine vollständig verwaltete, mit MySQL und PostgreSQL kompatible relationale Datenbank-Engine, die einen bis zu fünffachen Durchsatz von MySQL und einen bis zu dreimal höheren Durchsatz von PostgreSQL ausgibt, ohne den Großteil Ihrer vorhandenen Anwendung zu ändern. Weitere Informationen finden Sie unter Was ist Amazon Aurora? im Amazon-Aurora-Benutzerhandbuch.

Wichtig

Die resultierende Anwendung in diesem Tutorial verwendet einen Ortsindex, der Geocodierungsergebnisse speichert. Weitere Informationen zu den Gebühren für die Speicherung von Geokodierungsergebnissen finden Sie unter Amazon Location Service – Preise.

Beispielcode ist im Amazon Location Service-Beispiel-Repository auf verfügbarGitHub, das eine -AWS CloudFormationVorlage enthält.

Übersicht

Die Architektur umfasst die folgenden Integrationen:

• Diese Lösung verwendet eine Amazon-Location-Place-Indexressource, um Geocodierungsabfragen mit der Operation zu unterstützenSearchPlaceIndexForText.

• AWS Lambda verwendet ein Python-Lambda, das Adressen geocodiert, wenn eine IAM-Richtlinie die Berechtigung erteilt, AWS Lambda die Geocodierungsoperation von Amazon Location aufzurufen, SearchPlaceIndexForText.

• Erteilen Sie die Berechtigung Amazon Aurora PostgreSQL zum Aufrufen der Geocodierungs-Lambda-Funktion mithilfe einer benutzerdefinierten SQL-Funktion.

Voraussetzungen

Bevor Sie beginnen, benötigen Sie die folgenden Voraussetzungen:

• Ein -Amazon Aurora PostgreSQLCluster. Weitere Informationen zum Erstellen eines Amazon-Aurora-DB-Clusters finden Sie im Amazon-Aurora-Benutzerhandbuch.

  Anmerkung

  Wenn Ihr Amazon-Aurora-Cluster nicht öffentlich verfügbar ist, müssen Sie Amazon Aurora auch so konfigurieren, dass eine Verbindung zu AWS Lambda in einer Virtual Private Cloud (VPC) in Ihrem AWS Konto hergestellt wird. Weitere Informationen finden Sie unter Gewähren von Amazon Aurora PostgreSQL Zugriff auf AWS Lambda.

• Ein SQL-Entwicklertool zum Herstellen einer Verbindung mit dem Amazon Aurora PostgreSQL Cluster.

Schnellstart

Als Alternative zu den Schritten in diesem Tutorial können Sie einen Quick Stack starten, um eine -AWS LambdaFunktion bereitzustellen, die den Amazon Location-Vorgang unterstütztSearchPlaceIndexForText. Dadurch wird Ihr AWS Konto automatisch so konfiguriert, dass Amazon Aurora aufrufen kannAWS Lambda.

Sobald Sie Ihr AWS Konto konfiguriert haben, müssen Sie:

• Fügen Sie das Lambda-Feature zu Amazon Aurora hinzu. Weitere Informationen finden Sie unter Hinzufügen der IAM-Rolle zu einem Amazon-Aurora-DB-Cluster in Gewähren von Amazon Aurora PostgreSQL Zugriff auf AWS Lambda.

• Laden Sie die benutzerdefinierte Funktion in Ihre Datenbank. Siehe Aufrufen der AWS Lambda-Funktion.

Erstellen einer Ortsindex-Ressource

Erstellen Sie zunächst eine Ortsindexressource zur Unterstützung von Geocodierungsabfragen.

1. Öffnen Sie die Amazon Location Service-Konsole unter https://console.aws.amazon.com/location/.

2. Wählen Sie im linken Navigationsbereich Indizes platzieren aus.

3. Füllen Sie die folgenden Felder aus:

   • Name – Geben Sie einen Namen für die Ortsindex-Ressource ein. Zum Beispiel AuroraPlaceIndex. Maximal 100 Zeichen. Gültige Einträge umfassen alphanumerische Zeichen, Bindestriche, Punkte und Unterstriche.

   • Beschreibung – Geben Sie eine optionale Beschreibung ein. Zum Beispiel den Ortsindex für Amazon Aurora .

4. Wählen Sie unter Datenanbieter einen verfügbaren Datenanbieter aus, der mit Ihrer Ortsindexressource verwendet werden soll. Wenn Sie keine Präferenz haben, empfehlen wir, mit Esri zu beginnen.

5. Geben Sie unter Datenspeicheroptionen die Option Ja an, Ergebnisse werden gespeichert. Dies weist darauf hin, dass Sie beabsichtigen, die Geocodierungsergebnisse in einer Datenbank zu speichern.

6. (Optional) Geben Sie unter Markierungen einen Tag Key (Schlüssel) und einen Value (Wert) ein. Dadurch wird ein Tag für Ihre neue Ortsindexressource hinzugefügt. Weitere Informationen finden Sie unter Markieren Ihrer Ressourcen.

7. Wählen Sie Ortsindex erstellen aus.

Erstellen einer -AWS LambdaFunktion für die Geocodierung

Um eine Verbindung zwischen Amazon Aurora PostgreSQL und Amazon Location Service herzustellen, benötigen Sie eine -AWS LambdaFunktion, um Anfragen von der Datenbank-Engine zu verarbeiten. Diese Funktion übersetzt das benutzerdefinierte Lambda-Funktionsereignis und ruft die Amazon Location-Operation aufSearchPlaceIndexForText.

Sie können die Funktion mithilfe der AWS LambdaKonsole, der AWS Command Line Interfaceoder der AWS Lambda APIs erstellen.

So erstellen Sie eine benutzerdefinierte Lambda-Funktion mithilfe der Konsole

1. Öffnen Sie die AWS Lambda-Konsole unter https://console.aws.amazon.com/lambda/.

2. Wählen Sie in der linken Navigation Funktionen aus.

3. Wählen Sie Funktion erstellen und stellen Sie sicher, dass Von Grund auf neu erstellen ausgewählt ist.

4. Füllen Sie die folgenden Felder aus:

   • Funktionsname – Geben Sie einen eindeutigen Namen für Ihre Funktion ein. Gültige Einträge umfassen alphanumerische Zeichen, Bindestriche und Unterstriche ohne Leerzeichen. Zum Beispiel AuroraGeocoder.

   • Laufzeit – Wählen Sie Python 3.8 aus.

5. Wählen Sie Funktion erstellen.

6. Wählen Sie die Registerkarte Code, um den Editor zu öffnen.

7. Überschreiben Sie den Platzhaltercode in lambda_function.py wie folgt:

   from os import environ
   
   import boto3
   from botocore.config import Config
   
   # load the place index name from the environment, falling back to a default
   PLACE_INDEX_NAME = environ.get("PLACE_INDEX_NAME", "AuroraPlaceIndex")
   
   location = boto3.client("location", config=Config(user_agent="Amazon Aurora PostgreSQL"))
   
   """
   This Lambda function receives a payload from Amazon Aurora and translates it to
   an Amazon Location `SearchPlaceIndex` call and returns the results as-is, to be
   post-processed by a PL/pgSQL function.
   """
   def lambda_handler(event, context):
       kwargs = {}
       
       if event.get("biasPosition") is not None:
           kwargs["BiasPosition"] = event["biasPosition"]
   
       if event.get("filterBBox") is not None:
           kwargs["FilterBBox"] = event["filterBBox"]
   
       if event.get("filterCountries") is not None:
           kwargs["FilterCountries"] = event["filterCountries"]
   
       if event.get("maxResults") is not None:
           kwargs["MaxResults"] = event["maxResults"]
       
       return location.search_place_index_for_text(
           IndexName=PLACE_INDEX_NAME,
           Text=event["text"],
           **kwargs)["Results"]

8. Wenn Sie Ihren Ortsindex anders als benannt habenAuroraPlaceIndex, erstellen Sie eine Umgebungsvariable mit dem Namen PLACE_INDEX_NAME, um den Ressourcennamen zuzuweisen:

   • Wählen Sie auf der Registerkarte Konfiguration die Option Umgebungsvariablen aus.

   • Wählen Sie Bearbeiten und dann Umgebungsvariable hinzufügen aus.

   • Geben Sie für Schlüssel einPLACE_INDEX_NAME.

   • Geben Sie für Wert den Namen Ihrer Ortsindex-Ressource ein.

9. Wählen Sie Bereitstellen, um die aktualisierte Funktion zu speichern.

10. Wählen Sie im Dropdown-Menü Test die Option Testereignis konfigurieren aus.

11. Wählen Sie Create new test event aus.

12. Geben Sie das folgende Testereignis ein:

    {
      "text": "Baker Beach",
      "biasPosition": [-122.483, 37.790],
      "filterCountries": ["USA"]
    }

13. Wählen Sie Test, um die Lambda-Funktion zu testen.

14. Wählen Sie die Registerkarte Konfiguration aus.

15. Wählen Sie unter Allgemeine Konfiguration die Option Berechtigungen aus.

16. Wählen Sie unter Ausführungsrolle den Hyperlink-Rollennamen aus, um Amazon Location Service Berechtigungen für Ihre Lambda-Funktion zu erteilen.

17. Wählen Sie auf der Registerkarte Berechtigungen: Wählen Sie das Dropdown-Menü Berechtigungen hinzufügen und dann Inline-Richtlinie erstellen aus.

18. Wählen Sie den Tab JSON.

19. Fügen Sie die folgende IAM-Richtlinie hinzu:

    • Die folgende Richtlinie erteilt die Berechtigung zum Senden SearchPlaceIndexForText an die Ortsindex-Ressource AuroraPlaceIndex.

      {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Effect": "Allow",
            "Action": "geo:SearchPlaceIndexForText",
            "Resource": "arn:aws:geo:<Region>:<AccountId>:place-index/AuroraPlaceIndex"
          }
        ]
      }

20. Wählen Sie Richtlinie prüfen.

21. Geben Sie den Namen einer Richtlinie ein. Zum Beispiel AuroraPlaceIndexReadOnly.

22. Wählen Sie Richtlinie erstellen aus.

Gewähren von Amazon Aurora PostgreSQL Zugriff auf AWS Lambda

Bevor eine -AWS LambdaFunktion aufrufen Amazon Aurora PostgreSQL kann, müssen Sie Zugriffsberechtigungen erteilen.

Wenn Ihr Amazon Aurora PostgreSQL Cluster nicht öffentlich zugänglich ist, müssen Sie zunächst einen VPC-Endpunkt für erstellenAWS Lambda, damit Amazon Aurora Ihre Lambda-Funktion aufrufen kann.

Erstellen eines VPC-Endpunkts für AWS Lambda

Anmerkung

Dieser Schritt ist nur erforderlich, wenn Ihr Amazon Aurora PostgreSQL Cluster nicht öffentlich zugänglich ist.

1. Öffnen Sie die Amazon Virtual Private Cloud Console.

2. Wählen Sie in der linken Navigation Endpunkte aus.

3. Wählen Sie Endpunkt erstellen aus.

4. Geben Sie im Filter Service Name „lambda“ ein und wählen Sie dann auscom.amazonaws.<region>.lambda.

5. Wählen Sie die VPC aus, die Ihren Aurora-Cluster enthält.

6. Wählen Sie für jede Availability Zone ein Subnetz aus.

7. Geben Sie im Filter Sicherheitsgruppe „Standard“ oder den Namen der Sicherheitsgruppe ein, der Ihr Aurora-Cluster angehört, und wählen Sie dann die Sicherheitsgruppe aus.

8. Wählen Sie Endpunkt erstellen aus.

Erstellen Sie eine IAM-Richtlinie, um die Berechtigung zum Aufrufen Ihrer AWS Lambda Funktion zu erteilen

1. Öffnen Sie die IAM-Konsole.

2. Erweitern Sie in der linken Navigation die Option Zugriffsverwaltung, um Richtlinien auszuwählen.

3. Wählen Sie Richtlinie erstellen aus.

4. Geben Sie auf der Registerkarte JSON die folgende Richtlinie ein:

   • Im Folgenden finden Sie ein Beispiel für eine IAM-Richtlinie, die die Amazon Aurora PostgreSQL Berechtigung zum Aufrufen der AuroraGeocoder AWS Lambda Funktion erteilt.

   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "lambda:InvokeFunction",
               "Resource": [
                   "arn:aws:lambda:<Region>:<AccountId>:function:AuroraGeocoder"
               ]
           }
       ]
   }

5. Wählen Sie Weiter: Tags, um optionale Tags hinzuzufügen.

6. Wählen Sie Weiter: Prüfen aus.

7. Überprüfen Sie Ihre Richtlinie und geben Sie die folgenden Details für die Richtlinie ein:

   • Name – Verwenden Sie alphanumerische Zeichen und „+=,.@-_“. Maximal 128 Zeichen. Zum Beispiel AuroraGeocoderInvoke.

   • Beschreibung – Geben Sie eine optionale Beschreibung ein. Verwenden Sie alphanumerische Zeichen und '+=,.@-_'. Maximal 1000 Zeichen.

8. Wählen Sie Richtlinie erstellen aus. Notieren Sie sich den ARN für diese Richtlinie, mit dem Sie die Richtlinie an eine IAM-Rolle anfügen.

Erstellen einer IAM-Rolle, um Amazon Relational Database Service (Amazon RDS) die Berechtigung zu erteilen

Durch Erstellen einer IAM-Rolle Amazon Aurora PostgreSQL kann die Rolle in Ihrem Namen übernehmen, um auf Ihre Lambda-Funktion zuzugreifen. Weitere Informationen finden Sie unter Erstellen einer Rolle zum Delegieren von Berechtigungen an einen IAM-Benutzer im IAM-Benutzerhandbuch.

Das folgende Beispiel ist ein -AWS CLIBefehl, der eine Rolle mit dem Namen erstelltAuroraGeocoderInvokeRole:

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"
        }
    ] 
}'

Hängen Sie Ihre IAM-Richtlinie an die IAM-Rolle an

Wenn Sie über eine IAM-Rolle verfügen, fügen Sie die von Ihnen erstellte IAM-Richtlinie an.

Das folgende Beispiel ist ein -AWS CLIBefehl, der die Richtlinie AuroraGeocoderInvoke an die Rolle anfügtAuroraGeocoderInvokeRole.

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

Hinzufügen der IAM-Rolle zu einem Amazon Aurora-DB-Cluster

Das folgende Beispiel ist ein -AWS CLIBefehl zum Hinzufügen einer IAM-Rolle zu einem Amazon Aurora PostgreSQL DB-Cluster mit dem Namen MyAuroraCluster.

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

Aufrufen der AWS Lambda-Funktion

Nachdem Sie die Berechtigung zum Aufrufen Ihrer Lambda-Funktion Amazon Aurora PostgreSQL für die Geocodierung erteilt haben, können Sie eine Amazon Aurora PostgreSQL benutzerdefinierte Funktion erstellen, um die AWS Lambda Geocodierungsfunktion aufzurufen. Weitere Informationen finden Sie unter Aufrufen einer -AWS LambdaFunktion aus einem Amazon Aurora PostgreSQL-DB-Cluster im Amazon-Aurora-Benutzerhandbuch.

Installieren der erforderlichen PostgreSQL-Erweiterungen

Informationen zum Installieren der erforderlichen PostgreSQL-Erweiterungen aws_lambda und aws _commons Erweiterungen finden Sie unter Übersicht über die Verwendung einer Lambda-Funktion im Amazon-Aurora-Benutzerhandbuch.

CREATE EXTENSION IF NOT EXISTS aws_lambda CASCADE;

Installieren der erforderlichen PostGIS-Erweiterungen

PostGIS ist eine Erweiterung von PostgreSQL zur Speicherung und Verwaltung von Geodaten. Weitere Informationen finden Sie unter Arbeiten mit der PostGIS-Erweiterung im Amazon Relational Database Service-Benutzerhandbuch.

CREATE EXTENSION IF NOT EXISTS postgis;

Erstellen einer benutzerdefinierten SQL-Funktion, die die Lambda-Funktion aufruft

Erstellen Sie in einem SQL-Editor eine neue benutzerdefinierte Funktion, f_SearchPlaceIndexForText um die Funktion aufzurufenAuroraGeocoder:

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

Rufen Sie die SQL-Funktion auf, um von Aurora aus zu geocodieren

Wenn Sie die SQL-Anweisung ausführen, wird die Lambda-Funktion aufgerufenAuroraGeocoder, die Adressdatensätze aus der Datenbanktabelle in der Amazon Aurora PostgreSQL Datenbank übernimmt und sie mithilfe einer Ortsindexressource geocodiert.

Anmerkung

Amazon Aurora PostgreSQL ruft die Lambda-Funktion für jeden Aufruf der benutzerdefinierten SQL-Funktion auf.

Wenn Sie 50 Zeilen geocodieren, Amazon Aurora PostgreSQL ruft die Lambda-Funktion 50 Mal auf. Ein Aufruf für jede Zeile.

Die folgende f_SearchPlaceIndexForText SQL-Funktion stellt Anforderungen an die SearchPlaceIndexForText API von Amazon Location über die AuroraGeocoder Lambda-Funktion. Die Funktion gibt eine geom Spalte zurück, die eine PostGIS-Geometrie ist, die in Text ST_AsText(geom) konvertiert wird.

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

Standardmäßig enthält die Rückgabe eine Zeile. Um zusätzliche Zeilen bis zum MaxResults Limit anzufordern, führen Sie die folgende SQL-Anweisung aus, während Sie ein BiasPosition und eine Einschränkung auf die Ergebnisse in Kanada angeben.

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

Um Ergebnisse mithilfe eines Begrenzungsrahmens zu filtern, übergeben Sie einen Box2D als filter_bbox:

• FilterBBox – Filtert die Ergebnisse, indem es Stellen innerhalb eines Begrenzungsrahmens zurückgibt. Dieser Parameter ist optional.

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

Weitere Informationen zu PostGIS-Typen und -Funktionen finden Sie in der PostGIS-Referenz.

Anreicherung einer Datenbank mit Adressdaten

Sie können eine formatierte Adresse erstellen und gleichzeitig mithilfe der Amazon Location-Operation normalisieren und geocodieren, SearchPlaceIndexForText wenn eine Datenbanktabelle mit den folgenden Daten in die folgenden Spalten unterteilt ist:

• id

• address

• city

• state

• zip

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;

Das folgende Beispiel veranschaulicht eine resultierende Datentabellenzeile:

 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)

Aktualisieren der Datenbanktabelle und Auffüllen von Spalten

Im folgenden Beispiel wird die Tabelle aktualisiert und Spalten mit Ergebnissen von SearchPlaceIndexForText Abfragen gefüllt:

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;

Nächste Schritte

Beispielcode ist im Amazon Location Service-Beispiel-Repository auf verfügbarGitHub, das eine -AWS CloudFormationVorlage enthält.