

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erste Schritte mit Amazon Location Service
<a name="getting-started"></a>

Dieses Thema hilft Ihnen bei den ersten Schritten mit Amazon Location Service. Folgen Sie diesen Schritten, um Ihre erste Anwendung zu erstellen und zu verstehen, wie Sie die passende Amazon Location API auf der Grundlage gängiger Anwendungsfälle auswählen. 

1. **Richten Sie Ihr AWS Konto ein und greifen Sie darauf zu.**

   Wenn Sie noch kein Konto haben, werden Sie aufgefordert, eines zu erstellen. Mit dem AWS kostenlosen Kontingent erhalten Sie drei Monate kostenloses Kontingent für Amazon Location Service.

   Wenn Sie bereits ein Konto haben, müssen Sie Zugriff auf Amazon Location Service gewähren.

   Fahren Sie mit dem [Einrichten Ihres Kontos](set-up.md) Thema fort.

1. **Authentifizierung verstehen und einrichten.**

   Um Amazon Location verwenden zu können, muss einem Benutzer Zugriff auf die Ressourcen gewährt werden APIs , aus denen Amazon Location besteht. API Key, Amazon Cognito und AWS Identity and Access Management (IAM) sind drei Optionen, um Zugriff auf Ihre Ressourcen und Aktionen zu gewähren (APIs). 

   Fahren Sie mit dem Thema fort. [Authentifizieren Sie sich mit Amazon Location Service](access.md)

1. **Erstellen Sie Ihre erste Standortanwendung.**

   Erfahren Sie[Erstellen Sie Ihre erste Amazon Location Maps and Places-Anwendung](first-app.md), wie Sie Ihre erste „Hello World“ -Anwendung erstellen.

1. **Wählen Sie die richtige API.**

   Amazon Location bietet eine umfangreiche Auswahl an Orten APIs , Routen, Karten, Geofences und Trackern, um eine Vielzahl von Geschäftsanwendungsfällen zu lösen. 

   Weitere Informationen zur Auswahl einer Amazon Location API finden Sie unter[Wählen Sie die richtige API](choose-an-api.md).

# Einrichten Ihres Kontos
<a name="set-up"></a>

In diesem Abschnitt wird beschrieben, was Sie tun müssen, um Amazon Location Service nutzen zu können. Sie müssen über einen Amazon-Standort verfügen AWS-Konto und Zugriff darauf für Benutzer eingerichtet haben, die ihn verwenden möchten.

## Ich bin neu bei AWS
<a name="new-user"></a>

### Melde dich an für ein AWS-Konto
<a name="sign-up-for-aws"></a>

Wenn Sie noch keine haben AWS-Konto, führen Sie die folgenden Schritte aus, um eine zu erstellen.

**Um sich für eine anzumelden AWS-Konto**

1. Öffnen Sie [https://portal.aws.amazon.com/billing/die Anmeldung.](https://portal.aws.amazon.com/billing/signup)

1. Folgen Sie den Online-Anweisungen.

   Während der Anmeldung erhalten Sie einen Telefonanruf oder eine Textnachricht und müssen einen Verifizierungscode über die Telefontasten eingeben.

   Wenn Sie sich für eine anmelden AWS-Konto, *Root-Benutzer des AWS-Kontos*wird eine erstellt. Der Root-Benutzer hat Zugriff auf alle AWS-Services und Ressourcen des Kontos. Als bewährte Sicherheitsmethode weisen Sie einem Benutzer Administratorzugriff zu und verwenden Sie nur den Root-Benutzer, um [Aufgaben auszuführen, die Root-Benutzerzugriff erfordern](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS sendet Ihnen nach Abschluss des Anmeldevorgangs eine Bestätigungs-E-Mail. Du kannst jederzeit deine aktuellen Kontoaktivitäten einsehen und dein Konto verwalten, indem du zu [https://aws.amazon.com/](https://aws.amazon.com/)gehst und **Mein Konto** auswählst.

### Erstellen eines Benutzers mit Administratorzugriff
<a name="create-an-admin"></a>

Nachdem Sie sich für einen angemeldet haben AWS-Konto, sichern Sie Ihren Root-Benutzer des AWS-Kontos AWS IAM Identity Center, aktivieren und erstellen Sie einen Administratorbenutzer, sodass Sie den Root-Benutzer nicht für alltägliche Aufgaben verwenden.

**Sichern Sie Ihre Root-Benutzer des AWS-Kontos**

1.  Melden Sie sich [AWS-Managementkonsole](https://console.aws.amazon.com/)als Kontoinhaber an, indem Sie **Root-Benutzer** auswählen und Ihre AWS-Konto E-Mail-Adresse eingeben. Geben Sie auf der nächsten Seite Ihr Passwort ein.

   Hilfe bei der Anmeldung mit dem Root-Benutzer finden Sie unter [Anmelden als Root-Benutzer](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) im *AWS-Anmeldung -Benutzerhandbuch* zu.

1. Aktivieren Sie die Multi-Faktor-Authentifizierung (MFA) für den Root-Benutzer.

   Anweisungen finden Sie unter [Aktivieren eines virtuellen MFA-Geräts für Ihren AWS-Konto Root-Benutzer (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) im *IAM-Benutzerhandbuch*.

**Erstellen eines Benutzers mit Administratorzugriff**

1. Aktivieren Sie das IAM Identity Center.

   Anweisungen finden Sie unter [Aktivieren AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Gewähren Sie einem Administratorbenutzer im IAM Identity Center Benutzerzugriff.

   *Ein Tutorial zur Verwendung von IAM-Identity-Center-Verzeichnis als Identitätsquelle finden Sie IAM-Identity-Center-Verzeichnis im Benutzerhandbuch unter [Benutzerzugriff mit der Standardeinstellung konfigurieren](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html).AWS IAM Identity Center *

**Anmelden als Administratorbenutzer**
+ Um sich mit Ihrem IAM-Identity-Center-Benutzer anzumelden, verwenden Sie die Anmelde-URL, die an Ihre E-Mail-Adresse gesendet wurde, als Sie den IAM-Identity-Center-Benutzer erstellt haben.

  Hilfe bei der Anmeldung mit einem IAM Identity Center-Benutzer finden Sie [im *AWS-Anmeldung Benutzerhandbuch* unter Anmeldung beim AWS Access-Portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html).

**Weiteren Benutzern Zugriff zuweisen**

1. Erstellen Sie im IAM-Identity-Center einen Berechtigungssatz, der den bewährten Vorgehensweisen für die Anwendung von geringsten Berechtigungen folgt.

   Anweisungen hierzu finden Sie unter [ Berechtigungssatz erstellen](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

1. Weisen Sie Benutzer einer Gruppe zu und weisen Sie der Gruppe dann Single Sign-On-Zugriff zu.

   Eine genaue Anleitung finden Sie unter [ Gruppen hinzufügen](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) im *AWS IAM Identity Center -Benutzerhandbuch*.

## Ich habe bereits ein Konto AWS
<a name="existing-user"></a>

**Zugriff auf Amazon Location Service gewähren**

Ihre Benutzer ohne Administratorrechte haben standardmäßig keine Berechtigungen. Bevor sie auf Amazon Location zugreifen können, müssen Sie die Erlaubnis erteilen, indem Sie eine IAM-Richtlinie mit bestimmten Berechtigungen anhängen. Achten Sie darauf, dass Sie bei der Gewährung des Zugriffs auf Ressourcen das Prinzip der geringsten Rechte einhalten. 

**Anmerkung**  
Informationen darüber, wie Sie nicht authentifizierten Benutzern Zugriff auf die Funktionen von Amazon Location Service gewähren können (z. B. in einer webbasierten Anwendung), finden Sie unter. [Authentifizieren Sie sich mit Amazon Location Service](access.md)

Die folgende Beispielrichtlinie gibt einem Benutzer die Erlaubnis, auf alle Amazon Location-Operationen zuzugreifen. Weitere Beispiele finden Sie unter [Beispiele für identitätsbasierte Richtlinien für Amazon Location Service](security-iam.md#security_iam_id-based-policy-examples).

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "geo:*",
        "geo-maps:*",
        "geo-places:*",
        "geo-routes:*"
      ],
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

Um Zugriff zu gewähren, fügen Sie Ihren Benutzern, Gruppen oder Rollen Berechtigungen hinzu:
+ Benutzer und Gruppen in AWS IAM Identity Center:

  Erstellen Sie einen Berechtigungssatz. Befolgen Sie die Anweisungen unter [Erstellen eines Berechtigungssatzes](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) im *AWS IAM Identity Center -Benutzerhandbuch*.
+ Benutzer, die in IAM über einen Identitätsanbieter verwaltet werden:

  Erstellen Sie eine Rolle für den Identitätsverbund. Befolgen Sie die Anleitung unter [Eine Rolle für einen externen Identitätsanbieter (Verbund) erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) im *IAM-Benutzerhandbuch*.
+ IAM-Benutzer:
  + Erstellen Sie eine Rolle, die Ihr Benutzer annehmen kann. Befolgen Sie die Anleitung unter [Eine Rolle für einen IAM-Benutzer erstellen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) im *IAM-Benutzerhandbuch*.
  + (Nicht empfohlen) Weisen Sie einem Benutzer eine Richtlinie direkt zu oder fügen Sie einen Benutzer zu einer Benutzergruppe hinzu. Befolgen Sie die Anweisungen unter [Hinzufügen von Berechtigungen zu einem Benutzer (Konsole)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) im *IAM-Benutzerhandbuch*.

Wenn Sie Anwendungen erstellen, die Amazon Location Service verwenden, benötigen einige Benutzer möglicherweise nicht authentifizierten Zugriff. Informationen zu diesen Anwendungsfällen finden Sie unter [Aktivieren eines nicht authentifizierten Zugriffs mit Amazon](authenticating-using-cognito.md) Cognito.

# Verwenden Sie die Amazon Location Service Service-Konsole, um sich zu authentifizieren
<a name="set-up-auth"></a>

**Anmerkung**  
Weitere Informationen zur Authentifizierung finden Sie unter[Authentifizieren Sie sich mit Amazon Location Service](access.md).

Um Amazon Location Service nutzen zu können, muss einem Benutzer Zugriff auf die Ressourcen gewährt werden APIs , aus denen Amazon Location besteht. Standardmäßig ist für die Verwendung des Amazon-Standorts APIs eine Authentifizierung erforderlich. Sie können entweder Amazon Cognito oder API-Schlüssel verwenden, um anonyme Benutzer zu authentifizieren und zu autorisieren. 

Im [Erstellen Sie Ihre erste Amazon Location Maps and Places-Anwendung](first-app.md) Tutorial wird die Anwendung anonym verwendet, was bedeutet, dass sich Ihre Benutzer nicht anmelden müssen. In der Anleitung erstellen Sie API-Schlüssel für die Verwendung in der Beispielanwendung.

Gehen Sie wie folgt vor, um Ihren ersten API-Schlüssel zu erstellen.

1. Wählen Sie in der [https://console.aws.amazon.com/location](https://console.aws.amazon.com/location) im linken Menü **API-Schlüssel** aus.

1. Wählen Sie auf der Seite mit den **API-Schlüsseln** die Option **API-Schlüssel erstellen** aus.

1. Geben Sie auf der Seite **API-Schlüssel erstellen** die folgenden Informationen ein:
   + **Name** — Ein Name für Ihren API-Schlüssel, z. `MyHelloWorldApp` B.
   + **Beschreibung** — Eine optionale Beschreibung für Ihren API-Schlüssel.
   + **Aktionen** — Geben Sie die Aktionen an, die Sie mit diesem API-Schlüssel autorisieren möchten. **Sie müssen mindestens **Geo-Maps:get\$1 und GEO-places:Search\$1** auswählen.**
   + **Ablaufzeit — Fügen Sie optional ein Ablaufdatum** und eine Ablaufzeit für Ihren API-Schlüssel hinzu. Weitere Informationen finden Sie unter [Die wichtigsten bewährten Methoden für die API](using-apikeys.md#api-keys-best-practices).
   + **Client-Einschränkungen** — Fügen Sie optional eine oder mehrere Webdomänen oder eine oder mehrere Android- oder Apple-Apps hinzu, in denen Sie den API-Schlüssel verwenden können. Wenn der API-Schlüssel beispielsweise die Ausführung einer Anwendung auf der Website ermöglichen soll`example.com`, können Sie ihn `*.example.com/` als zulässigen Referrer angeben.
   + **Tags** — Fügen Sie optional Tags zum API-Schlüssel hinzu.
**Wichtig**  
Wir empfehlen Ihnen, die Verwendung Ihres API-Schlüssels zu schützen, indem Sie entweder eine Ablaufzeit oder einen Referrer, falls nicht beides, festlegen.

1. Wählen Sie **API-Schlüssel erstellen**, um den API-Schlüssel zu erstellen.

1. Auf der Detailseite für den API-Schlüssel finden Sie Informationen zu dem API-Schlüssel, den Sie erstellt haben. 

   Wählen Sie **API-Schlüssel anzeigen** und kopieren Sie den Schlüsselwert, um ihn später im [Erstellen Sie Ihre erste Amazon Location Maps and Places-Anwendung](first-app.md) Tutorial zu verwenden. Der Schlüsselwert wird das Format haben`v1.public.a1b2c3d4...`. 

# Wählen Sie die richtige API
<a name="choose-an-api"></a>

Dieses Thema hilft Ihnen bei der Auswahl einer Amazon Location Service API auf der Grundlage gängiger Anwendungsfälle, die Sie möglicherweise mit standortbezogenen Daten und Diensten lösen möchten. 

Zuordnungen  
Karten bieten Zugriff auf dynamische und statische Kartentypen für eine Vielzahl von Anwendungen. Weitere Informationen finden Sie unter[Amazon Location Service – Karten](maps.md).  
+ **Dynamische Karten**: Interaktive Karten, die in Echtzeit angepasst werden können, sodass Benutzer Daten schwenken, zoomen und überlagern können. Weitere Informationen finden Sie unter[Dynamische Karten](dynamic-maps.md).
+ **Statische Karten**: Statische Bilder von Karten, die bestimmte Orte oder Routen ohne interaktive Elemente anzeigen, geeignet für Anwendungen mit eingeschränkter Interaktivität. Weitere Informationen finden Sie unter[Statische Karten](static-maps.md).

Routen  
Routen bieten Funktionen zur Berechnung optimierter Pfade zwischen Standorten. Diese Funktionen unterstützen Anwendungen, die Logistikplanung, Entfernungsberechnungen und Routenoptimierung erfordern. Benutzer können zur Verbesserung der Genauigkeit auch Ortspunkte an Straßen anbringen. Weitere Informationen finden Sie unter[Amazon Location Service – Routen](routes.md).  
+ **CalculateIsolines**: Generiert Isolinien auf der Grundlage von Reisezeit oder Entfernung. Dies ist nützlich für die Definition von Einzugsgebieten oder Erreichbarkeitszonen. Weitere Informationen finden Sie unter. [Isolinien berechnen](calculate-isolines.md)
+ **CalculateRouteMatrix**: Bietet eine Matrix von Entfernungen und Reisezeiten zwischen verschiedenen Start- und Zielorten und unterstützt so die Logistik und Reiseplanung. Weitere Informationen finden Sie unter[Routenmatrix berechnen](calculate-route-matrix.md).
+ **CalculateRoutes**: Berechnet optimierte Routen für die Navigation point-to-point oder die Navigation mit mehreren Stopps, einschließlich anpassbarer Routing-Einstellungen. Weitere Informationen finden Sie unter. [Routen berechnen](calculate-routes.md)
+ **OptimizeWaypoints**: Optimiert die Reihenfolge der Wegpunkte für die effizienteste Reiseroute und minimiert so Entfernung oder Zeit. Weitere Informationen finden Sie unter. [Wegpunkte optimieren](actions-optimize-waypoints.md)
+ **SnapToRoads**: Ordnet die Koordinaten an den nächstgelegenen Straßenwegen an und verbessert so die GPS-Genauigkeit, indem Punkte auf bekannten Straßen erfasst werden. Weitere Informationen finden Sie unter. [Snap to Roads](snap-to-roads.md)

Orte  
Orte ermöglichen es Anwendungen, Informationen zu Sehenswürdigkeiten, Adressen und bestimmten Orten zu suchen, zu finden und abzurufen. Diese Funktionen verbessern standortbezogene Dienste, indem sie Kontext bereitstellen und die Benutzererfahrung bei Suchfunktionen verbessern. Weitere Informationen finden Sie unter[Amazon Location Service – Orte](places.md).   
+ **Geocode**: Konvertiert Adressen oder Ortsnamen in geografische Koordinaten (Längengrad, Breitengrad) und unterstützt damit Anwendungen, die für die Kartierung und räumliche Analyse eine address-to-location Transformation erfordern. Weitere Informationen finden Sie unter [Geokodieren](geocode.md).
+ **Reverse-Geocode**: Konvertiert geografische Koordinaten in die nächstgelegene Adresse oder den nächstgelegenen Ortsnamen und stellt so den Kontext für einen Standort bereit. Weitere Informationen finden Sie unter[Umgekehrter Geocode](reverse-geocode.md).
+ **Automatische Vervollständigung**: Schlägt mögliche Vervollständigungen für vom Benutzer eingegebenen Text vor und verbessert so die Effizienz bei der Sucheingabe. Weitere Informationen finden Sie unter. [Automatisch vervollständigen](autocomplete.md)
+ **GetPlace**: Ruft detaillierte Informationen zu einem bestimmten Ort ab, einschließlich Attributen wie Adresse, Kontaktdaten und Öffnungszeiten. Weitere Informationen finden Sie unter[GetPlace](get-place.md).
+ **SearchNearby**: Findet Orte innerhalb eines bestimmten Radius um einen bestimmten geographischen Punkt und eignet sich für die Suche „in meiner Nähe“. Weitere Informationen finden Sie unter[In der Nähe suchen](search-nearby.md).
+ **SearchText**: Ermöglicht die textbasierte Suche nach Orten oder Sehenswürdigkeiten auf der Grundlage eines Schlüsselworts oder einer Wortgruppe, ideal für die Suche nach Orten anhand des Namens oder der Beschreibung. Weitere Informationen finden Sie unter[Text suchen](search-text.md).
+ **Vorschlagen**: Bietet während der Eingabe Vorschläge für Suchbegriffe und verbessert so die Suchrelevanz und das Benutzererlebnis. Weitere Informationen finden Sie unter[Vorschlagen](suggest.md).

Geozäune  
Geofencing ermöglicht es Anwendungen, geografische Grenzen zu definieren und Eingangs- oder Austrittsereignisse innerhalb dieser Regionen zu überwachen. Zu den Funktionen gehören das Erstellen, Aktualisieren und Löschen von Geofences sowie die Konfiguration von Benachrichtigungen oder Auslösern für standortbezogene Aktionen, wenn überwachte Geräte Geofence-Grenzen überschreiten. Ideal für Benachrichtigungen in der Nähe, Sicherheitsüberwachung und Inventarverfolgung in vordefinierten Bereichen. Weitere Informationen finden Sie unter. [Amazon Location Service Geofences](geofences.md)

Tracker  
Tracking ermöglicht die Echtzeitüberwachung der Standorte von Geräten oder Vermögenswerten im Laufe der Zeit. Zu den Funktionen gehören das Hinzufügen von verfolgten Geräten, die Aktualisierung ihrer Standortdaten und das Abrufen historischer Positionsdaten. Tracker sind nützlich, um Flotten zu verwalten, Personal zu überwachen und die Sicherheit wertvoller Vermögenswerte zu gewährleisten, indem sie up-to-date Standortdaten und Bewegungsmuster bereitstellen. Weitere Informationen finden Sie unter. [Amazon Location Service Tracker](trackers.md)

# Erstellen Sie Ihre erste Amazon Location Maps and Places-Anwendung
<a name="first-app"></a>

In diesem Abschnitt erstellen Sie Ihre erste Anwendung mit Maps and Places.

**Voraussetzung:**

Wenn Sie in den [Verwenden Sie die Amazon Location Service Service-Konsole, um sich zu authentifizieren](set-up-auth.md) Schritten bereits einen API-Schlüssel erstellt haben, lassen Sie uns beginnen. 

Wenn Sie noch keinen API-Schlüssel erstellt haben, folgen Sie den Anweisungen, [Verwenden Sie die Amazon Location Service Service-Konsole, um sich zu authentifizieren](set-up-auth.md) bevor Sie mit der Erstellung der Anwendung fortfahren. Wenn Sie Fragen haben, finden Sie weitere [Unterstützte Regionen mit Amazon-Standort](location-regions.md) Informationen unter [Verwenden Sie API-Schlüssel zur Authentifizierung](using-apikeys.md) und.

## Web
<a name="qs-web"></a>

Hier finden Sie ein step-by-step Tutorial zum Erstellen einer Amazon Location Service Service-Kartenanwendung mit MapLibre GL JS. Diese Anleitung führt Sie durch die Einrichtung der Karte, das Hinzufügen von Gestaltungsoptionen und die Aktivierung der Ortssuchfunktion.

### Richten Sie die erste Seite ein
<a name="qs-initial-page"></a>

In diesem Abschnitt richten wir die erste Seiten- und Ordnerstruktur ein.

#### Fügen Sie die erforderlichen Bibliotheken und Stylesheets hinzu
<a name="qs-initial-add-library"></a>

Erstellen Sie eine Datei `index.html`. Um die Karte zu rendern, benötigen Sie MapLibre GL JS und MapLibre GL Geocoder. Sie werden die Stylesheets MapLibre und die Geocoder-Stylesheets und -Skripte hinzufügen. JavaScript 

Kopieren Sie den folgenden Code und fügen Sie ihn in Ihre Datei ein. `index.html`

```
<!DOCTYPE html>
<html lang="en">
<head>

    <title>Amazon Location Service - Getting Started with First Map App</title>
    <meta charset='utf-8'>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="Interactive map application using Amazon Location Service">

    <!--Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
    <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
    
    <!--Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
    <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
    
    <!--Link to amazon-location JavaScript librarie -->
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
    
    <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
    <script src="utils.js"></script>
    <link rel="stylesheet" href="style.css"/>
   

</head>
<body>
    <main> 
        
    </main>
    <script> 
        // Step 1: Setup API Key and AWS Region 
        // Step 2.1 Add maps to application
        // Step 2.2 initialize the map
        // Step 3: Add places features to application
        // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
        // Step 3.2: Add search box to the map
        // Step 3.3.: Setup map click functionality
        // Add functions
    </script>
</body>
</html>
```

#### Erstellen Sie den Map-Container
<a name="qs-create-map-container"></a>

 Erstellen Sie unter dem `<body>` Element der HTML-Datei ein `<div>` Element in Ihrem HTML-Code, das die Map aufnehmen soll. Sie können dies `<div>` in Ihrem CSS gestalten, um die Abmessungen nach Bedarf für Ihre Anwendung festzulegen. Sie müssen die CSS-Datei,`style.css`, aus unserem GitHub Repository herunterladen. Dies wird Ihnen helfen, sich auf die Geschäftslogik zu konzentrieren. 

 Speichern Sie die `index.html` Dateien `style.css` und im selben Ordner. 

 Laden Sie die `style.css` Datei von herunter [GitHub](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/style.css). 

```
<main role="main" aria-label="Map Container">
    <div id="map"></div>
</main>
```

#### Fügen Sie API-Schlüssel und AWS Regionsdetails hinzu
<a name="qs-create-add-key"></a>

Fügen Sie den API-Schlüssel, den Sie erstellt haben, zusammen mit der AWS Region, in [Verwenden Sie API-Schlüssel zur Authentifizierung](using-apikeys.md) der der Schlüssel erstellt wurde, zu dieser Datei hinzu. 

```
<!DOCTYPE html>
<html lang="en">
.....
.....
<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        // Step 1: Setup API Key and AWS Region 
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        // Step 2: Add maps to application
            // Step 2.1 initialize the map
            // Step 2.2 Add navigation controls to the map
        // Step 3: Add places feature to application        
            // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
            // Step 3.2: Add search box to the map
            // Step 3.3.: Setup map click functionality
    </script>
</body>
</html>
```

### Fügen Sie Ihrer Anwendung eine Karte hinzu
<a name="qs-add-map"></a>

In diesem Abschnitt werden wir der Anwendung Kartenfunktionen hinzufügen. Bevor Sie beginnen, sollten sich Ihre Dateien in dieser Ordnerstruktur befinden. 

 Falls Sie dies noch nicht getan haben, laden Sie die `style.css` Datei bitte von herunter [GitHub](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/style.css). 

```
|---FirstApp [Folder]
|-------------- index.html [File]
|-------------- style.css [File]
```

#### Erstellen Sie eine Funktion zur Initialisierung der Map
<a name="qs-initialize-map-function"></a>

Um Ihre Map einzurichten, erstellen Sie nach der Zeile `//Add functions` die folgende Funktion. `initializeMap(...)`

Wählen Sie eine anfängliche Position in der Mitte und eine Zoomstufe. In diesem Beispiel haben wir Vancouver, Kanada, als Kartenmittelpunkt mit einer Zoomstufe von 10 festgelegt. Fügen Sie Navigationssteuerungen für einfaches Zoomen hinzu.

```
/**
 * Initializes the map with the specified style and color scheme.
 */
function initializeMap(mapStyle = "Standard", colorScheme = "Dark") {
     const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
     const map = new maplibregl.Map({
         container: 'map',                 // The ID of the map container
         style: styleUrl,                  // The style URL for the map
         center: [-123.116226, 49.246292], // Starting center coordinates
         zoom: 10,                         // Initial zoom level
         validateStyle: false              // Disable style validation
     });
     return map;                           // Return the initialized map
}
```

#### Initialisieren Sie die Karte
<a name="qs-initialize-map"></a>

Rufen Sie `initializeMap(...)` auf, um die Map zu initialisieren. Optional können Sie sie nach der Funktion mit Ihrem bevorzugten Stil und Farbschema initialisieren. `initializeMap` Weitere Stiloptionen finden Sie unter[AWS Kartenstile und Funktionen](map-styles.md).

```
// Step 1: Setup API Key and AWS Region 
const API_KEY = "Your_API_Key";
const AWS_REGION = "Region_where_you_created_API_Key";

// Step 2.1 Add maps to application
// Step 2.2 initialize the map
const map = initializeMap("Standard","Light");

// Step 3: Add places features to application
```

Öffnen Sie die Karte `index.html` in einem Browser, um sich die Karte in Aktion anzusehen.

#### Navigationskontrolle hinzufügen
<a name="qs-add-navigation"></a>

Optional können Sie der Karte Navigationssteuerungen (Zoom und Drehung) hinzufügen. Dies sollte nach dem Anruf erfolgen`initializeMap(...)`.

```
// Step 2.1 initialize the map
const map = initializeMap("Standard","Light");

// Step 2.2 Add navigation controls to the map
map.addControl(new maplibregl.NavigationControl());

// Step 3: Add places features to application
```

#### Überprüfen Sie den Kartencode
<a name="qs-add-final"></a>

Herzlichen Glückwunsch\$1 Ihre erste App ist bereit, eine Karte zu verwenden. `index.html`In einem Browser öffnen. Stellen Sie sicher, dass `style.css` es sich im selben Ordner befindet wie`index.html`.

Ihr endgültiger HTML-Code sollte so aussehen:

```
<!DOCTYPE html>
<html lang="en">
<head>

   <title>Amazon Location Service - Getting Started with First Map App</title>
   <meta charset='utf-8'>
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="description" content="Interactive map application using Amazon Location Service">

   <!-- Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
   <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
   
   <!-- Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
   <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
   
   <!-- Link to amazon-location JavaScript library -->
   <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
   <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
   
   <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
   <script src="utils.js"></script>
   <link rel="stylesheet" href="style.css"/>
</head>

<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        
        function initializeMap(mapStyle, colorScheme) {
            const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
        
            const map = new maplibregl.Map({
                container: 'map',                 // ID of the HTML element for the map
                style: styleUrl,                  // URL for the map style
                center: [-123.116226, 49.246292], // Initial map center [longitude, latitude]
                zoom: 10                          // Initial zoom level
            });
            map.addControl(new maplibregl.NavigationControl());    
            return map;
        }
        
        const map = initializeMap("Standard", "Light");
        
    </script>
</body>
</html>
```

### Fügen Sie Ihrer Bewerbung Orte hinzu
<a name="qs-add-places"></a>

In diesem Abschnitt werden wir die Funktionen zum Hinzufügen von Orten zur Anwendung einrichten. Laden Sie die JavaScript Datei herunter von GitHub, [https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/utils.js](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/utils.js).

Bevor Sie beginnen, sollten sich Ihre Dateien in dieser Ordnerstruktur befinden:

```
|---FirstApp [Folder]
|-------------- index.html [File]
|-------------- style.css [File]
|-------------- utils.js [File]
```

#### Funktion zum Erstellen erstellen GeoPlaces
<a name="qs-create-geoplaces"></a>

Um Suchfunktionen hinzuzufügen, initialisieren Sie die `GeoPlaces` Klasse mit `AuthHelper` und`AmazonLocationClient`. Fügen Sie vor dem `</script>` Tag die folgende `getGeoPlaces(map)` Funktion hinzu. `index.html`

```
/**
 * Gets a GeoPlaces instance for Places operations.
 */
function getGeoPlaces(map) {
    const authHelper = amazonLocationClient.withAPIKey(API_KEY, AWS_REGION);                      // Authenticate using the API key and AWS region
    const locationClient = new amazonLocationClient.GeoPlacesClient(authHelper.getClientConfig()); // Create a GeoPlaces client
    const geoPlaces = new GeoPlaces(locationClient, map);                                          // Create GeoPlaces instance
    return geoPlaces;                                                                              // Return the GeoPlaces instance
}
```

#### Funktion erstellen, um der Anwendung ein Suchfeld hinzuzufügen
<a name="qs-add-searchbox"></a>

Fügen Sie vor dem `</script>` Tag die folgenden `createPopup(feature)` Funktionen `addSearchBox(map, geoPlaces)``renderPopup(feature)`, und hinzu`index.html`, um die Einrichtung der Suchfunktion abzuschließen.

```
/**
 * Adds search box to the map.
 */
function addSearchBox(map, geoPlaces) {
    const searchBox = new MaplibreGeocoder(geoPlaces, {
        maplibregl,
        showResultsWhileTyping: true,                    // Show results while typing
        debounceSearch: 300,                             // Debounce search requests
        limit: 30,                                       // Limit number of results
        popuprender: renderPopup,                        // Function to render popup
        reverseGeocode: true,                            // Enable reverse geocoding
        zoom: 14,                                        // Zoom level on result selection
        placeholder: "Search text or nearby (lat,long)"  // Placeholder text for search box.
    });
    
    // Add the search box to the map
    map.addControl(searchBox, 'top-left'); 

    // Event listener for when a search result is selected
    searchBox.on('result', async (event) => {
        const { id, result_type } = event.result;                     // Get result ID and type
        if (result_type === "Place") {                                // Check if the result is a place
            const placeResults = await geoPlaces.searchByPlaceId(id); // Fetch details for the selected place
            if (placeResults.features.length) {
                createPopup(placeResults.features[0]).addTo(map);     // Create and add popup for the place
            }
        }
    });
}

/**
 * Renders the popup content for a given feature.
 */
function renderPopup(feature) {
    return `
        <div class="popup-content">
            <span class="${feature.place_type.toLowerCase()} badge">${feature.place_type}</span><br>
            ${feature.place_name}
        </div>`;
}

/**
 * Creates a popup for a given feature and sets its position.
 */
function createPopup(feature) {
    return new maplibregl.Popup({ offset: 30 })      // Create a new popup
        .setLngLat(feature.geometry.coordinates)     // Set the popup position
        .setHTML(renderPopup(feature));              // Set the popup content
}
```

#### Fügen Sie der Anwendung ein Suchfeld hinzu
<a name="qs-add-searchbox-to-application"></a>

Erstellen Sie ein `GeoPlaces` Objekt, indem Sie es `getGeoPlaces(map)` wie in Abschnitt 3.1 definiert aufrufen und dann aufrufen`addSearchBox(map, geoPlaces)`, um das Suchfeld zur Anwendung hinzuzufügen.

```
// Step 2: Add maps to application
// Step 2.1 initialize the map
const map = initializeMap("Standard","Light");
// Step 2.2 Add navigation controls to the map
map.addControl(new maplibregl.NavigationControl()); 

// Step 3: Add places feature to application        
// Step 3.1: Get GeoPlaces instance. It will be used for adding search box and map click functionality
const geoPlaces = getGeoPlaces(map);
// Step 3.2: Add search box to the map
addSearchBox(map, geoPlaces);
```

Ihre Ortssuche ist einsatzbereit. Öffnen Sie es `index.html` in einem Browser, um es in Aktion zu sehen.

#### Funktion hinzufügen, um ein Popup anzuzeigen, wenn der Benutzer auf die Karte klickt
<a name="qs-add-map-click-feature"></a>

Erstellen Sie eine Funktion`addMapClick(map, geoPlaces)`, um ein Popup anzuzeigen, wenn der Benutzer auf die Karte klickt. Fügen Sie diese Funktion direkt vor dem `</script>` Tag hinzu.

```
/**
 * Sets up reverse geocoding on map click events.
 */
function addMapClick(map, geoPlaces) {
    map.on('click', async ({ lngLat }) => {                     // Listen for click events on the map
        const response = await geoPlaces.reverseGeocode({ query: [lngLat.lng, lngLat.lat], limit: 1, click: true }); // Perform reverse geocoding

        if (response.features.length) {                         // If there are results
            const clickMarker = new maplibregl.Marker({ color: "orange" }); // Create a marker
            const feature = response.features[0];               // Get the clicked feature
            const clickedPopup = createPopup(feature);          // Create popup for the clicked feature
            clickMarker.setLngLat(feature.geometry.coordinates) // Set marker position
                .setPopup(clickedPopup)                         // Attach popup to marker
                .addTo(map);                                    // Add marker to the map

            clickedPopup.on('close', () => clickMarker.remove()).addTo(map); // Remove marker when popup is closed
        }
    });
}
```

#### Rufen Sie die Funktion auf, um die Kartenklick-Funktion hinzuzufügen
<a name="qs-call-map-click-feature"></a>

Um die Aktion zum Klicken auf die Karte zu aktivieren, rufen Sie `addMapClick(map, geoPlaces)` nach der Zeile auf, die enthält`addSearchBox(map, geoPlaces)`.

```
// Step 3: Add places feature to application        
// Step 3.1: Get GeoPlaces instance. It will be used for adding search box and map click functionality
const geoPlaces = getGeoPlaces(map);
// Step 3.2: Add search box to the map
addSearchBox(map, geoPlaces);
// Step 3.3: Setup map click functionality
addMapClick(map, geoPlaces);
```

#### Sehen Sie sich die App Maps and Places an
<a name="qs-review-places"></a>

Herzlichen Glückwunsch\$1 Ihre erste Anwendung ist bereit, Maps and Places zu verwenden. `index.html`In einem Browser öffnen. Stellen Sie sicher`style.css`, dass Sie `utils.js` sich im selben Ordner befinden wie`index.html`. 

Ihr endgültiger HTML-Code sollte so aussehen:

```
<!DOCTYPE html>
<html lang="en">
<head>

   <title>Amazon Location Service - Getting Started with First Map App</title>
    <meta charset='utf-8'>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="Interactive map application using Amazon Location Service">

    <!--Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
    <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
    
    <!--Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
    <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
    
    <!--Link to amazon-location JavaScript librarie -->
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
    
    <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
    <script src="utils.js"></script>
    <link rel="stylesheet" href="style.css"/>
   

</head>
<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        // Step 1: Setup API Key and AWS Region
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        
        
        // Step 2: Add maps to application
        // Step 2.1 initialize the map
        const map = initializeMap("Standard","Light");
        // Step 2.2 Add navigation controls to the map
        map.addControl(new maplibregl.NavigationControl()); 

        // Step 3: Add places feature to application        
        // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
        const geoPlaces =  getGeoPlaces(map);
        // Step 3.2: Add search box to the map
        addSearchBox(map, geoPlaces);
        // Step 3.3.: Setup map click functionality
        addMapClick(map, geoPlaces); 
                
 

        /**
         * Functions to add maps and places feature.
         */
         
         /**
         * Initializes the map with the specified style and color scheme.
         */ 
        function initializeMap(mapStyle = "Standard", colorScheme = "Dark") {
            const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
            const map = new maplibregl.Map({
                container: 'map',                   // The ID of the map container
                style: styleUrl,                    // The style URL for the map
                center: [-123.116226, 49.246292],   // Starting center coordinates
                zoom: 10,                           // Initial zoom level
                validateStyle: false                // Disable style validation
            });
            return map;                             // Return the initialized map
        }
        
        /**
         * Gets a GeoPlaces instance for Places operations.
         */
        function getGeoPlaces(map) {
            const authHelper =  amazonLocationClient.withAPIKey(API_KEY, AWS_REGION);                      // Authenticate using the API key and AWS region
            const locationClient = new amazonLocationClient.GeoPlacesClient(authHelper.getClientConfig()); // Create a GeoPlaces client
            const geoPlaces = new GeoPlaces(locationClient, map);                                          // Create GeoPlaces instance
                return geoPlaces;                                                                          // Return the GeoPlaces instance
        }
        
         /**
         * Adds search box to the map.
         */
        
        function addSearchBox(map, geoPlaces) {
            const searchBox = new MaplibreGeocoder(geoPlaces, {
                maplibregl,
                showResultsWhileTyping: true,                    // Show results while typing
                debounceSearch: 300,                             // Debounce search requests
                limit: 30,                                       // Limit number of results
                popuprender: renderPopup,                        // Function to render popup
                reverseGeocode: true,                            // Enable reverse geocoding
                zoom: 14,                                        // Zoom level on result selection
                placeholder: "Search text or nearby (lat,long)"  // Place holder text for search box.  
            });
            
            // Add the search box to the map
            map.addControl(searchBox, 'top-left'); 

            // Event listener for when a search result is selected
            searchBox.on('result', async (event) => {
                const { id, result_type } = event.result;                     // Get result ID and type
                if (result_type === "Place") {                                // Check if the result is a place
                    const placeResults = await geoPlaces.searchByPlaceId(id); // Fetch details for the selected place
                    if (placeResults.features.length) {
                        createPopup(placeResults.features[0]).addTo(map);     // Create and add popup for the place
                    }
                }
            });
        }

        /**
         * Renders the popup content for a given feature.
         */
        function renderPopup(feature) {
            return `
                <div class="popup-content">
                    <span class="${feature.place_type.toLowerCase()} badge">${feature.place_type}</span><br>
                    ${feature.place_name}
                </div>`;
        }

        /**
         * Creates a popup for a given feature and sets its position.
         */
        function createPopup(feature) {
            return new maplibregl.Popup({ offset: 30 })      // Create a new popup
                .setLngLat(feature.geometry.coordinates)     // Set the popup position
                .setHTML(renderPopup(feature));              // Set the popup content
        }
        
        /**
         * Sets up reverse geocoding on map click events.
         */
        function addMapClick(map, geoPlaces) {
            map.on('click', async ({ lngLat }) => {                     // Listen for click events on the map
                const response = await geoPlaces.reverseGeocode({ query: [lngLat.lng, lngLat.lat], limit: 1, click:true }); // Perform reverse geocoding

                if (response.features.length) {                         // If there are results
                    const clickMarker = new maplibregl.Marker({ color: "orange" }); // Create a marker
                    const feature = response.features[0];               // Get the clicked feature
                    const clickedPopup = createPopup(feature);          // Create popup for the clicked feature
                    clickMarker.setLngLat(feature.geometry.coordinates) // Set marker position
                        .setPopup(clickedPopup)                         // Attach popup to marker
                        .addTo(map);                                    // Add marker to the map

                    clickedPopup.on('close', () => clickMarker.remove()).addTo(map); // Remove marker when popup is closed
                }
            });
        }
        
    </script>
</body>
</html>
```

### Erkunde mehr
<a name="qs-whats-next"></a>

Sie haben das Schnellstart-Tutorial abgeschlossen und sollten eine Vorstellung davon haben, wie Amazon Location Service zum Erstellen von Anwendungen verwendet wird. Um mehr aus Amazon Location herauszuholen, können Sie sich die folgenden Ressourcen ansehen:
+ **Einzelheiten zu den Vorschlägen abfragen** — Erwägen Sie, den `GeoPlaces` Kurs zu erweitern oder einen ähnlichen Ansatz zu verwenden`ReverseGeocode`, um mehr Details zu den von der `Suggestion` API zurückgegebenen Ergebnissen zu erhalten. 
+ **Wählen Sie die richtige API für Ihre Geschäftsanforderungen** — Um die beste Amazon Location API für Ihre Anforderungen zu ermitteln, sehen Sie sich diese Ressource an:[Wählen Sie die richtige API](choose-an-api.md). 
+ **Schauen Sie sich die Anleitungen zu Amazon Location an —** Tutorials und weitere Ressourcen finden Sie im [Amazon Location Service Developer Guide](https://docs.aws.amazon.com/location/). 
+ **Dokumentation und Produktinformationen** — Vollständige Dokumentation finden Sie im [Amazon Location Service Developer Guide](https://docs.aws.amazon.com/location/). Um mehr über das Produkt zu erfahren, gehen Sie auf die [Produktseite von Amazon Location Service](https://aws.amazon.com/location). 

# Erstellen Sie Ihre erste Geofences and Trackers-Anwendung
<a name="first-geofence-app"></a>

In diesem Abschnitt erstellen Sie eine Anwendung, die die wichtigsten Funktionen der Verwendung von Amazon Location Geofences and Trackers demonstriert. Die Anwendungen demonstrieren, wie ein Tracker und Geofence mithilfe einer Kombination aus Lambda- und Amazon AWS IoT Location-Funktionen interagieren. Wählen Sie die iOS- oder Android-Plattform, um loszulegen. 

Bevor Sie mit der Erstellung Ihrer Anwendung beginnen, folgen Sie den Anweisungen unter [Verwenden Sie die Amazon Location Service Service-Konsole, um sich zu authentifizieren](set-up-auth.md) So gewähren Sie den entsprechenden Zugriff.

**Topics**
+ [Erstellen Sie eine iOS-Anwendung](ios-geofence-app.md)
+ [Erstellen einer Android-Anwendung](android-geofence-app.md)

# Erstellen Sie eine iOS-Anwendung
<a name="ios-geofence-app"></a>

Gehen Sie wie folgt vor, um mithilfe von Amazon Location Service eine iOS-Anwendung zu erstellen.

Klonen Sie die Projektdateien von [GitHub](https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking-with-geofence-notifications).

## Erstellen Sie Amazon-Standortressourcen für Ihre App
<a name="qs-ios-tracking-resources"></a>

Sie können Amazon Location Service Service-Ressourcen generieren, sobald Ihr AWS Konto bereit ist. Diese Ressourcen sind für die Ausführung der bereitgestellten Codefragmente unerlässlich.

**Anmerkung**  
Wenn Sie noch kein AWS Konto erstellt haben, [erstellen Sie bitte ein AWS](https://portal.aws.amazon.com/billing/signup#/start/email) Konto.

Zunächst müssen Sie eine Amazon Cognito Identity Pool-ID erstellen. Gehen Sie dazu wie folgt vor:

1. Navigieren Sie in der AWS Konsole zum Amazon Cognito-Service und wählen Sie dann im Menü auf der linken Seite **Identitätspools** und dann **Identitätspool erstellen** aus. 

1. Vergewissern Sie sich, dass **Gastzugriff** aktiviert ist, und klicken Sie auf **Weiter**, um fortzufahren.

1. Erstellen Sie als Nächstes eine neue IAM-Rolle oder Verwenden Sie eine vorhandene IAM-Rolle.

1. Geben Sie einen Namen für den Identitätspool ein und stellen Sie sicher, dass Identity Pool Zugriff auf `(geo)` Amazon-Standortressourcen für die Karte und den Tracker hat, die Sie im nächsten Verfahren erstellen werden.

1. 

Jetzt müssen Sie in der AWS Amazon Location-Konsole eine Karte erstellen und gestalten. Gehen Sie dazu wie folgt vor:

1. Navigieren Sie in der Amazon Location-Konsole zum [Abschnitt Maps](https://console.aws.amazon.com/location/maps/home) und wählen Sie **Create Map** aus, um eine Vorschau der verfügbaren Kartenstile anzuzeigen.

1. Geben Sie der neuen Kartenressource einen **Namen** und eine **Beschreibung**. Notieren Sie sich den Namen, den Sie der Kartenressource zuweisen, so wie er später im Tutorial verwendet wird.

1. Berücksichtigen Sie bei der Auswahl eines Kartenstils den Kartendatenanbieter. Weitere Informationen finden Sie in Abschnitt 82 der [AWS Servicebedingungen](https://aws.amazon.com/service-terms).

1.  Akzeptieren Sie die [Allgemeinen Geschäftsbedingungen für Amazon-Standorte und](https://aws.amazon.com/service-terms/#:~:text=82.%20Amazon%20Location%20Service) wählen Sie dann **Karte erstellen** aus. Nachdem die Karte erstellt wurde, können Sie mit der Karte interagieren, indem Sie sie vergrößern, verkleinern oder in eine beliebige Richtung schwenken.

So erstellen Sie einen Tracker mit der Amazon Location-Konsole

1.  Öffnen Sie die [Amazon Location Service Service-Konsole](https://console.aws.amazon.com/location/).

1.  Wählen Sie im linken Navigationsbereich **Trackers** aus.

1.  Wählen Sie **Tracker erstellen**.

1.  Füllen Sie alle erforderlichen Felder aus.

1.  Wählen Sie unter **Positionsfilterung** die Option aus, die am besten zu Ihrer geplanten Nutzung Ihrer Tracker-Ressource passt. Wenn Sie die Positionsfilterung nicht einrichten, ist die Standardeinstellung TimeBased. Weitere Informationen finden Sie unter Trackers in diesem Handbuch und PositionFiltering in der Amazon Location Service Trackers API-Referenz.

1.  Wählen Sie „**Tracker erstellen“, um den Vorgang** abzuschließen.

## Erstellen Sie eine Geofence-Sammlung
<a name="qs-ios-tracking-geofence"></a>

Beim Erstellen einer Geofence-Sammlung können Sie entweder die Konsole, die API oder die CLI verwenden. Die folgenden Verfahren führen Sie durch die einzelnen Optionen.

Erstellen Sie mit der Amazon Location-Konsole eine Geofence-Sammlung:

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

1.  Wählen Sie im linken Navigationsbereich Geofence Collections aus.

1.  Wählen Sie Geofence-Sammlung erstellen.

1.  Geben Sie einen Namen und eine Beschreibung für die Sammlung an.

1.  Unter EventBridge CloudWatch Regel mit Ziel können Sie eine optionale EventBridge Regel erstellen, mit der Sie sofort auf Geofence-Ereignisse reagieren können. Dadurch kann Amazon Location Ereignisse in Amazon CloudWatch Logs veröffentlichen.

1.  Wählen Sie Geofence-Sammlung erstellen.

Erstellen Sie eine Geofence-Sammlung mithilfe des Amazon-Standorts: APIs

Verwenden Sie den CreateGeofenceCollection Vorgang von Amazon Location Geofences APIs aus. Das folgende Beispiel verwendet eine API-Anfrage, um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
POST /geofencing/v0/collections
Content-type: application/json
    {
        "CollectionName": "GOECOLLECTION_NAME",
        "Description": "Geofence collection 1 for shopping center",
        "Tags": { 
            "Tag1" : "Value1"
                }
    }
```

Erstellen Sie eine Geofence-Sammlung mithilfe von Befehlen: AWS CLI 

Verwenden Sie den Befehl create-geofence-collection. Im folgenden Beispiel wird eine verwendet AWS CLI , um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
aws location \ create-geofence-collection \
    --collection-name "GOECOLLECTION_NAME" \
    --description "Shopping center geofence collection" \
    --tags Tag1=Value1                 
```

## Verknüpfen Sie einen Tracker mit einer Geofence-Sammlung
<a name="qs-ios-tracking-link-geofence"></a>

Um einen Tracker mit einer Geofence-Sammlung zu verknüpfen, können Sie entweder die Konsole, die API oder die CLI verwenden. Die folgenden Verfahren führen Sie durch die einzelnen Optionen.

Verknüpfen Sie mithilfe der Amazon Location Service Service-Konsole eine Tracker-Ressource mit einer Geofence-Sammlung:

1. Öffnen Sie die Amazon Location-Konsole.

1. Wählen Sie im linken Navigationsbereich **Trackers** aus.

1. Wählen Sie unter **Device Trackers** den Namenslink des Ziel-Trackers aus.

1. Wählen Sie unter **Verknüpfte Geofence-Sammlungen** die Option Geofence-Sammlung **verknüpfen** aus.

1. Wählen Sie im **Fenster Verknüpfte Geofence-Sammlung eine Geofence-Sammlung** aus dem Drop-down-Menü aus.

1. Wählen Sie **Verknüpfen**.

1. Nachdem Sie die Tracker-Ressource verknüpft haben, wird ihr der Status Aktiv zugewiesen.

Verknüpfen Sie mithilfe des Amazon-Standorts eine Tracker-Ressource mit einer Geofence-Sammlung: APIs

Verwenden Sie den `` AsssociateTrackerConsumer Vorgang von den Amazon Location Trackers APIs aus. Im folgenden Beispiel wird eine API-Anfrage verwendet, die mithilfe ihres Amazon-Ressourcennamens (ARN) ExampleTracker mit einer Geofence-Sammlung verknüpft wird.

```
POST /tracking/v0/trackers/ExampleTracker/consumers
Content-type: application/json
        {
           "ConsumerArn": "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME"
        }
```

Verknüpfen Sie mithilfe von Befehlen eine Tracker-Ressource mit einer Geofence-Sammlung: AWS CLI 

Verwenden Sie den Befehl `associate-tracker-consumer `. Im folgenden Beispiel wird eine verwendet AWS CLI , um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
aws location \
associate-tracker-consumer \
    --consumer-arn "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME" \
    --tracker-name "ExampleTracker"
```

## Verwenden Sie AWS Lambda mit MQTT
<a name="qs-ios-tracking-lambda"></a>

Erstellen einer Lambda-Funktion:

Um eine Verbindung zwischen AWS IoT Core und Amazon Location Service herzustellen, benötigen Sie eine AWS Lambda Funktion zur Verarbeitung von Nachrichten, die von EventBridge CloudWatch Ereignissen weitergeleitet werden. Diese Funktion extrahiert alle Positionsdaten, formatiert sie für Amazon Location Service und übermittelt sie über die Amazon Location Tracker-API. Sie können diese Funktion über die AWS Lambda Konsole erstellen, oder Sie können die AWS Command Line Interface (AWS CLI) oder die AWS Lambda APIs verwenden. So erstellen Sie eine Lambda-Funktion, die mithilfe der Konsole Positionsaktualisierungen für Amazon Location veröffentlicht:

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

1. Wählen Sie in der linken Navigationsleiste Funktionen aus.

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

1. Füllen Sie die folgenden Felder aus:
   + ein Funktionsname
   + wählen Sie für die **Runtime-Option** Node.js 16.x.

1. Wählen Sie Funktion erstellen.

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

1. Überschreiben Sie den Platzhaltercode in index.js mit dem Folgenden:

   ```
   const AWS = require('aws-sdk')
   const iot = new AWS.Iot();
   exports.handler =  function(event) {
                 console.log("event===>>>", JSON.stringify(event));
                 var param = {
                   endpointType: "iot:Data-ATS"
                 };
                 iot.describeEndpoint(param, function(err, data) {
                   if (err) {
                     console.log("error===>>>", err, err.stack); // an error occurred
                   } else {
                     var endp = data['endpointAddress'];
                     const iotdata = new AWS.IotData({endpoint: endp});    
                     const trackerEvent = event["detail"]["EventType"];
                     const src = event["source"];
                     const time = event["time"];
                     const gfId = event["detail"]["GeofenceId"];
                     const resources = event["resources"][0];  
                     const splitResources = resources.split(".");  
                     const geofenceCollection = splitResources[splitResources.length - 1];
                     const coordinates = event["detail"]["Position"];                               
                     const deviceId = event["detail"]["DeviceId"]; 
                     console.log("deviceId===>>>", deviceId);
                     const msg =  {
                         "trackerEventType" : trackerEvent,
                         "source" : src,
                         "eventTime" : time,
                         "geofenceId" : gfId,
                         "coordinates": coordinates, 
                         "geofenceCollection": geofenceCollection
                       };
                     const params = {
                       topic: `${deviceId}/tracker`,
                       payload: JSON.stringify(msg),
                       qos: 0
                     };
                     iotdata.publish(params, function(err, data) {
                         if (err) {
                           console.log("error===>>>", err, err.stack); // an error occurred
                         } else {
                           console.log("Ladmbda triggered===>>>", trackerEvent);  // successful response 
                         }
                     }); 
                   }
                 });
               }
   ```

1. Wählen Sie Deploy, um die aktualisierte Funktion zu speichern.

1. Wählen Sie die Registerkarte Konfiguration aus.

1. Klicken Sie im Bereich Trigger auf Auslöser hinzufügen.

1. Wählen Sie im Feld Quelle EventBridge (CloudWatch Ereignisse) aus.

1. Wählen Sie das Optionsfeld `Existierende Regeln`.

1. Geben Sie den Regelnamen wie folgt ein: `-GEOFENCECOLLECTION\$1NAME`. AmazonLocationMonitor

1. Klicken Sie auf die Schaltfläche Hinzufügen.

1. Dadurch werden auch `Ressourcenbasierte Richtlinienerklärungen` auf der Registerkarte „Berechtigungen“ angehängt

MQTT-Testclient

1. Öffnen Sie die [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/iot/).

1. Wählen Sie im linken Navigationsbereich MQTT-Testclient aus.

1. Sie sehen einen Abschnitt mit dem Titel **MQTT-Testclient**, in dem Sie Ihre MQTT-Verbindung konfigurieren können.

1. Nachdem Sie die erforderlichen Einstellungen konfiguriert haben, klicken Sie auf die Schaltfläche **Connect**, um mithilfe der bereitgestellten Parameter eine Verbindung zum MQTT-Broker herzustellen.

1. Notieren Sie sich den Endpoint-Wert.

Sobald die Verbindung hergestellt ist, können Sie MQTT-Themen abonnieren oder Nachrichten zu Themen veröffentlichen, indem Sie die entsprechenden Eingabefelder in der MQTT-Testclient-Oberfläche verwenden. Als Nächstes fügen Sie die MQTT-Richtlinie hinzu:

1.  Erweitern Sie im Menü auf der linken Seite unter **Verwalten** die Option **Sicherheit** und klicken Sie auf **Richtlinien**.

1. Klicken Sie auf **die Schaltfläche Richtlinie erstellen**.

1. Geben Sie den Namen einer Richtlinie ein.

1. Wählen Sie im **Richtliniendokument** die Registerkarte **JSON** aus.

1. Kopieren Sie die unten gezeigte Richtlinie und fügen Sie sie ein. Achten Sie jedoch darauf, alle Elemente mit Ihrem `REGION` und zu aktualisieren`ACCOUNT_ID`:

   ```
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
                   {
                     "Action": [
                       "iot:Connect",
                       "iot:Publish",
                       "iot:Subscribe",
                       "iot:Receive"
                     ],
                     "Resource": [
                       "arn:aws:iot:REGION:ACCOUNT_ID:client/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/${cognito-identity.amazonaws.com:sub}/",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}/tracker"
                      ],
                      "Effect": "Allow"
                    }
                  ]
   }
   ```

1. Wählen Sie die Schaltfläche **Erstellen**, um den Vorgang abzuschließen.

## Richten Sie den Beispiel-App-Code ein
<a name="qs-ios-tracking-setup-sample"></a>

Um den Beispielcode einzurichten, müssen Sie die folgenden Tools installiert haben:
+ Git
+ XCode 15.3 oder später
+ iOS Simulator 16 oder höher

Gehen Sie wie folgt vor, um den Beispiel-App-Code einzurichten:

1. Klonen Sie das Git-Repository von dieser URL: [https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking- with-geofence-notifications](https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking-with-geofence-notifications).

1. Öffnen Sie die Projektdatei `AWSLocationSampleApp.xcodeproj`.

1. Warte auf den Prozess zur Paketauflösung.

1. **Optional**: Benennen Sie im Projektnavigationsmenü in die folgenden Werte `ConfigTemplate.xcconfig` um `Config.xcconfig` und geben Sie sie ein:

   ```
   IDENTITY_POOL_ID = `YOUR_IDENTITY_POOL_ID`
   MAP_NAME = `YOUR_MAP_NAME`
   TRACKER_NAME = `YOUR_TRACKER_NAME`
   WEBSOCKET_URL = `YOUR_MQTT_TEST_CLIENT_ENDPOINT`
   GEOFENCE_ARN = `YOUR_GEOFENCE_COLLECTION_NAME`
   ```

## Verwenden Sie die Beispiel-App
<a name="qs-ios-tracking-usage"></a>

Nachdem Sie den Beispielcode eingerichtet haben, können Sie die App nun auf einem iOS-Simulator oder einem physischen Gerät ausführen.

1. Erstellen Sie die App und führen Sie sie aus.

1. Die App fragt Sie nach Standort- und Benachrichtigungsberechtigungen. Sie müssen sie zulassen.

1. Tippen Sie auf die Schaltfläche `Cognito-Konfiguration`.

1. Wenn Sie die Werte in der Datei `Config.xcConfig` nicht ausgefüllt haben, müssen Sie das Feld mit den Ressourcenwerten ausfüllen, die Sie zuvor im Konfigurationsbildschirm erstellt haben.

   ```
   IDENTITY_POOL_ID = `YOUR_IDENTITY_POOL_ID`
   MAP_NAME = `YOUR_MAP_NAME`
   TRACKER_NAME = `YOUR_TRACKER_NAME`
   WEBSOCKET_URL = `YOUR_MQTT_TEST_CLIENT_ENDPOINT`
   GEOFENCE_ARN = `YOUR_GEOFENCE_COLLECTION_NAME`
   ```

1. Speichern Sie die Konfiguration

1. Sie können jetzt die Filteroptionen für Zeit, Entfernung und Genauigkeit sehen. Verwenden Sie sie nach Ihren Bedürfnissen.

1. Gehen Sie in der App zum Tab `Tracking` und Sie werden die Karte und die Schaltfläche `Tracking starten` sehen.

1. Wenn Sie die App auf einem Simulator installiert haben, möchten Sie möglicherweise Standortänderungen simulieren. Dies kann über die Menüoption Funktionen -> Standort erfolgen. Wählen Sie zum Beispiel Funktionen -> Standort -> Freeway Drive.

1. Tippen Sie auf die Schaltfläche `Tracking starten`. Sie sollten die Tracking-Punkte auf der Karte sehen.

1. Die App verfolgt auch die Standorte im Hintergrund. Wenn Sie die App also im Hintergrund bewegen, werden Sie um Erlaubnis gebeten, die Verfolgung im Hintergrundmodus fortzusetzen.

1. Sie können das Tracking beenden, indem Sie auf die Schaltfläche `Stop Tracking` tippen.

# Erstellen einer Android-Anwendung
<a name="android-geofence-app"></a>

Gehen Sie wie folgt vor, um mithilfe von Amazon Location Service eine iOS-Anwendung zu erstellen.

Klonen Sie die Projektdateien von [GitHub](https://github.com/aws-geospatial/amazon-location-samples-android/tree/main/tracking-with-geofence-notifications).

## Erstellen Sie Amazon-Standortressourcen für Ihre App
<a name="qs-android-tracking-resources"></a>

Sie können Amazon Location Service Service-Ressourcen generieren, sobald Ihr AWS Konto bereit ist. Diese Ressourcen sind für die Ausführung der bereitgestellten Codefragmente unerlässlich.

**Anmerkung**  
Wenn Sie noch kein AWS Konto erstellt haben, [erstellen Sie bitte ein AWS](https://portal.aws.amazon.com/billing/signup#/start/email) Konto.

Zunächst müssen Sie eine Amazon Cognito Identity Pool-ID erstellen. Gehen Sie dazu wie folgt vor:

1. Navigieren Sie in der AWS Konsole zum Amazon Cognito-Service und wählen Sie dann im Menü auf der linken Seite **Identitätspools** und dann **Identitätspool erstellen** aus. 

1. Vergewissern Sie sich, dass **Gastzugriff** aktiviert ist, und klicken Sie auf **Weiter**, um fortzufahren.

1. Erstellen Sie als Nächstes eine neue IAM-Rolle oder Verwenden Sie eine vorhandene IAM-Rolle.

1. Geben Sie einen Namen für den Identitätspool ein und stellen Sie sicher, dass Identity Pool Zugriff auf `(geo)` Amazon-Standortressourcen für die Karte und den Tracker hat, die Sie im nächsten Verfahren erstellen werden.

1. 

Jetzt müssen Sie in der AWS Amazon Location-Konsole eine Karte erstellen und gestalten. Gehen Sie dazu wie folgt vor:

1. Navigieren Sie in der Amazon Location-Konsole zum [Abschnitt Maps](https://console.aws.amazon.com/location/maps/home) und wählen Sie **Create Map** aus, um eine Vorschau der verfügbaren Kartenstile anzuzeigen.

1. Geben Sie der neuen Kartenressource einen **Namen** und eine **Beschreibung**. Notieren Sie sich den Namen, den Sie der Kartenressource zuweisen, so wie er später im Tutorial verwendet wird.

1. Berücksichtigen Sie bei der Auswahl eines Kartenstils den Kartendatenanbieter. Weitere Informationen finden Sie in Abschnitt 82 der [AWS Servicebedingungen](https://aws.amazon.com/service-terms).

1. Akzeptieren Sie die [Allgemeinen Geschäftsbedingungen für Amazon-Standorte und](https://aws.amazon.com/service-terms/#:~:text=82.%20Amazon%20Location%20Service) wählen Sie dann **Karte erstellen** aus. Nachdem die Karte erstellt wurde, können Sie mit der Karte interagieren, indem Sie sie vergrößern, verkleinern oder in eine beliebige Richtung schwenken.

So erstellen Sie einen Tracker mit der Amazon Location-Konsole

1.  Öffnen Sie die [Amazon Location Service Service-Konsole](https://console.aws.amazon.com/location/).

1. Wählen Sie im linken Navigationsbereich **Trackers** aus.

1. Wählen Sie **Tracker erstellen**.

1. Füllen Sie alle erforderlichen Felder aus.

1. Wählen Sie unter **Positionsfilterung** die Option aus, die am besten zu Ihrer geplanten Nutzung Ihrer Tracker-Ressource passt. Wenn Sie die Positionsfilterung nicht einrichten, ist die Standardeinstellung TimeBased. Weitere Informationen finden Sie unter Trackers in diesem Handbuch und PositionFiltering in der Amazon Location Service Trackers API-Referenz.

1. Wählen Sie „**Tracker erstellen“, um den Vorgang** abzuschließen.

## Erstellen Sie eine Geofence-Sammlung
<a name="qs-android-tracking-geofence"></a>

Beim Erstellen einer Geofence-Sammlung können Sie entweder die Konsole, die API oder die CLI verwenden. Die folgenden Verfahren führen Sie durch die einzelnen Optionen.

Erstellen Sie mit der Amazon Location-Konsole eine Geofence-Sammlung:

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

1. Wählen Sie im linken Navigationsbereich Geofence Collections aus.

1. Wählen Sie Geofence-Sammlung erstellen aus.

1. Geben Sie einen Namen und eine Beschreibung für die Sammlung an.

1. Unter EventBridge CloudWatch Regel mit Ziel können Sie eine optionale EventBridge Regel erstellen, mit der Sie sofort auf Geofence-Ereignisse reagieren können. Dadurch kann Amazon Location Ereignisse in Amazon CloudWatch Logs veröffentlichen.

1. Wählen Sie Geofence-Sammlung erstellen aus.

Erstellen Sie eine Geofence-Sammlung mithilfe des Amazon-Standorts: APIs

Verwenden Sie den CreateGeofenceCollection Vorgang von Amazon Location Geofences APIs aus. Das folgende Beispiel verwendet eine API-Anfrage, um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
POST /geofencing/v0/collections
Content-type: application/json
    {
    "CollectionName": "GOECOLLECTION_NAME",
    "Description": "Geofence collection 1 for shopping center",
    "Tags": { 
        "Tag1" : "Value1"
            }
    }
```

Erstellen Sie eine Geofence-Sammlung mithilfe von Befehlen: AWS CLI 

Verwenden Sie den Befehl create-geofence-collection. Im folgenden Beispiel wird eine verwendet AWS CLI , um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
aws location \ create-geofence-collection \
    --collection-name "GOECOLLECTION_NAME" \
    --description "Shopping center geofence collection" \
    --tags Tag1=Value1               
```

## Verknüpfen Sie einen Tracker mit einer Geofence-Sammlung
<a name="qs-android-tracking-link-geofence"></a>

Um einen Tracker mit einer Geofence-Sammlung zu verknüpfen, können Sie entweder die Konsole, die API oder die CLI verwenden. Die folgenden Verfahren führen Sie durch die einzelnen Optionen.

Verknüpfen Sie mithilfe der Amazon Location Service Service-Konsole eine Tracker-Ressource mit einer Geofence-Sammlung:

1. Öffnen Sie die Amazon Location-Konsole.

1. Wählen Sie im linken Navigationsbereich **Trackers** aus.

1. Wählen Sie unter **Device Trackers** den Namenslink des Ziel-Trackers aus.

1. Wählen Sie unter **Verknüpfte Geofence-Sammlungen** die Option Geofence-Sammlung **verknüpfen** aus.

1. Wählen Sie im **Fenster Verknüpfte Geofence-Sammlung eine Geofence-Sammlung** aus dem Drop-down-Menü aus.

1. Wählen Sie **Verknüpfen**.

1. Nachdem Sie die Tracker-Ressource verknüpft haben, wird ihr der Status Aktiv zugewiesen.

Verknüpfen Sie mithilfe des Amazon-Standorts eine Tracker-Ressource mit einer Geofence-Sammlung: APIs

Verwenden Sie den `` AsssociateTrackerConsumer Vorgang von Amazon Location Trackers APIs aus. Im folgenden Beispiel wird eine API-Anfrage verwendet, die mithilfe ihres Amazon-Ressourcennamens (ARN) ExampleTracker mit einer Geofence-Sammlung verknüpft wird.

```
POST /tracking/v0/trackers/ExampleTracker/consumers
Content-type: application/json
    {
    "ConsumerArn": "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME"
    }
```

Verknüpfen Sie mithilfe von Befehlen eine Tracker-Ressource mit einer Geofence-Sammlung: AWS CLI 

Verwenden Sie den Befehl `associate-tracker-consumer `. Im folgenden Beispiel wird eine verwendet AWS CLI , um eine Geofence-Sammlung namens zu erstellen. `GOECOLLECTION_NAME`

```
aws location \
associate-tracker-consumer \
    --consumer-arn "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME" \
    --tracker-name "ExampleTracker"
```

## Verwenden Sie AWS Lambda mit MQTT
<a name="qs-android-tracking-lambda"></a>

Erstellen einer Lambda-Funktion:

Um eine Verbindung zwischen AWS IoT Core und Amazon Location Service herzustellen, benötigen Sie eine AWS Lambda Funktion zur Verarbeitung von Nachrichten, die von EventBridge CloudWatch Ereignissen weitergeleitet werden. Diese Funktion extrahiert alle Positionsdaten, formatiert sie für Amazon Location Service und übermittelt sie über die Amazon Location Tracker-API. Sie können diese Funktion über die AWS Lambda Konsole erstellen, oder Sie können die AWS Command Line Interface (AWS CLI) oder die AWS Lambda APIs verwenden. So erstellen Sie eine Lambda-Funktion, die mithilfe der Konsole Positionsaktualisierungen für Amazon Location veröffentlicht:

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

1. Wählen Sie in der linken Navigationsleiste Funktionen aus.

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

1. Füllen Sie die folgenden Felder aus:
   + ein Funktionsname
   + wählen Sie für die **Runtime-Option** Node.js 16.x.

1. Wählen Sie Funktion erstellen.

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

1. Überschreiben Sie den Platzhaltercode in index.js mit dem Folgenden:

   ```
   const AWS = require('aws-sdk')
   const iot = new AWS.Iot();
   exports.handler =  function(event) {
       console.log("event===>>>", JSON.stringify(event));
       var param = {
           endpointType: "iot:Data-ATS"
           };
       iot.describeEndpoint(param, function(err, data) {
           if (err) {
               console.log("error===>>>", err, err.stack); // an error occurred
            } else {
                     var endp = data['endpointAddress'];
                     const iotdata = new AWS.IotData({endpoint: endp});    
                     const trackerEvent = event["detail"]["EventType"];
                     const src = event["source"];
                     const time = event["time"];
                     const gfId = event["detail"]["GeofenceId"];
                     const resources = event["resources"][0];  
                     const splitResources = resources.split(".");  
                     const geofenceCollection = splitResources[splitResources.length - 1];
                     const coordinates = event["detail"]["Position"];                               
                     const deviceId = event["detail"]["DeviceId"]; 
                     console.log("deviceId===>>>", deviceId);
                     const msg =  {
                         "trackerEventType" : trackerEvent,
                         "source" : src,
                         "eventTime" : time,
                         "geofenceId" : gfId,
                         "coordinates": coordinates, 
                         "geofenceCollection": geofenceCollection
                     };
       const params = {
           topic: `${deviceId}/tracker`,
           payload: JSON.stringify(msg),
           qos: 0
                };
       iotdata.publish(params, function(err, data) {
           if (err) {
               console.log("error===>>>", err, err.stack); // an error occurred
           } else {
               console.log("Ladmbda triggered===>>>", trackerEvent);  // successful response 
                  }
           }); 
          }
         });
        }
   ```

1. Wählen Sie Deploy, um die aktualisierte Funktion zu speichern.

1. Wählen Sie die Registerkarte Konfiguration aus.

1. Klicken Sie im Bereich Trigger auf Auslöser hinzufügen.

1. Wählen Sie im Feld Quelle EventBridge (CloudWatch Ereignisse) aus.

1. Wählen Sie das Optionsfeld `Existierende Regeln`.

1. Geben Sie den Regelnamen wie folgt ein: `-GEOFENCECOLLECTION\$1NAME`. AmazonLocationMonitor

1. Klicken Sie auf die Schaltfläche Hinzufügen.

1. Dadurch werden auch `Ressourcenbasierte Richtlinienerklärungen` auf der Registerkarte „Berechtigungen“ angehängt

MQTT-Testclient

1. Öffnen Sie die [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/iot/).

1. Wählen Sie im linken Navigationsbereich MQTT-Testclient aus.

1. Sie sehen einen Abschnitt mit dem Titel **MQTT-Testclient**, in dem Sie Ihre MQTT-Verbindung konfigurieren können.

1. Nachdem Sie die erforderlichen Einstellungen konfiguriert haben, klicken Sie auf die Schaltfläche **Connect**, um mithilfe der bereitgestellten Parameter eine Verbindung zum MQTT-Broker herzustellen.

1. Notieren Sie sich den Endpunktwert.

Sobald die Verbindung hergestellt ist, können Sie MQTT-Themen abonnieren oder Nachrichten zu Themen veröffentlichen, indem Sie die entsprechenden Eingabefelder verwenden, die in der MQTT-Testclient-Oberfläche bereitgestellt werden. Als Nächstes fügen Sie die MQTT-Richtlinie hinzu:

1.  Erweitern Sie im Menü auf der linken Seite unter **Verwalten** die Option **Sicherheit** und klicken Sie auf **Richtlinien**.

1. Klicken Sie auf **die Schaltfläche Richtlinie erstellen**.

1. Geben Sie den Namen einer Richtlinie ein.

1. Wählen Sie im **Richtliniendokument** die Registerkarte **JSON** aus.

1. Kopieren Sie die unten gezeigte Richtlinie und fügen Sie sie ein. Achten Sie jedoch darauf, alle Elemente mit Ihrem `REGION` und zu aktualisieren`ACCOUNT_ID`:

   ```
   {
    "Version": "2012-10-17",		 	 	 
    "Statement": [
                   {
                     "Action": [
                       "iot:Connect",
                       "iot:Publish",
                       "iot:Subscribe",
                       "iot:Receive"
                        ],
                     "Resource": [
                       "arn:aws:iot:REGION:ACCOUNT_ID:client/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/${cognito-identity.amazonaws.com:sub}/",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}/tracker"
                       ],
                     "Effect": "Allow"
                   }
                 ]
   }
   ```
**Anmerkung**  
Notieren Sie sich den Richtliniennamen und den Themennamen zur Verwendung im nächsten Verfahren.

1. Wählen Sie die Schaltfläche **Erstellen**, um den Vorgang abzuschließen.

Nachdem Sie das vorherige Verfahren abgeschlossen haben, aktualisieren Sie nun die Berechtigungen für die Gastrolle wie folgt:

1. Navigieren Sie zu Amazon Cognito und öffnen Sie Ihren Identitätspool. Fahren Sie dann mit dem Benutzerzugriff fort und wählen Sie die Gastrolle aus.

1. Klicken Sie auf Berechtigungsrichtlinien, um die Bearbeitung zu aktivieren.

   ```
   {
       'Version': '2012-10-17		 	 	 ',
       'Statement': [
           {
               'Action': [
                   'geo:GetMap*',
                   'geo:BatchUpdateDevicePosition',
                   'geo:BatchEvaluateGeofences',
                   'iot:Subscribe',
                   'iot:Publish',
                   'iot:Connect',
                   'iot:Receive',
                   'iot:AttachPrincipalPolicy',
                   'iot:AttachPolicy',
                   'iot:DetachPrincipalPolicy',
                   'iot:DetachPolicy'
               ],
               'Resource': [
                   'arn:aws:geo:us-east-1:{USER_ID}:map/{MAP_NAME}',
                   'arn:aws:geo:us-east-1:{USER_ID}:tracker/{TRACKER_NAME}',
                   'arn:aws:geo:us-east-1:{USER_ID}:geofence-collection/{GEOFENCE_COLLECTION_NAME}',
                   'arn:aws:iot:us-east-1:{USER_ID}:client/${cognito-identity.amazonaws.com:sub}',
                   'arn:aws:iot:us-east-1:{USER_ID}:topic/${cognito-identity.amazonaws.com:sub}',
                   'arn:aws:iot:us-east-1:{USER_ID}:topicfilter/${cognito-identity.amazonaws.com:sub}/*',
                   'arn:aws:iot:us-east-1:{USER_ID}:topic/${cognito-identity.amazonaws.com:sub}/tracker'
               ],
               'Effect': 'Allow'
           },
           {
               'Condition': {
                   'StringEquals': {
                       'cognito-identity.amazonaws.com:sub': '${cognito-identity.amazonaws.com:sub}'
                   }
               },
               'Action': [
                   'iot:AttachPolicy',
                   'iot:DetachPolicy',
                   'iot:AttachPrincipalPolicy',
                   'iot:DetachPrincipalPolicy'
               ],
               'Resource': [
                   '*'
               ],
               'Effect': 'Allow'
           }
       ]
   }
   ```

1. Mit den oben genannten Richtlinienänderungen sind nun alle erforderlichen AWS Ressourcen für die Anwendung entsprechend konfiguriert.

## Richten Sie den Beispiel-App-Code ein
<a name="qs-android-tracking-sample-app-code"></a>



1. Öffnen Sie Android Studio und wählen Sie in der **Versionskontrolle **Neu** und dann Projekt aus**.

1. Navigieren Sie zum Menü **Datei** in der oberen linken Ecke von Android Studio.

1. Wählen Sie im Drop-down-Menü „Neu“ aus.

1. Wählen Sie „Projekt aus der Versionskontrolle“.

1. Geben Sie die Repository-URL ein. Suchen Sie im daraufhin angezeigten Dialogfeld nach dem Feld mit der Bezeichnung „URL“.

1. Kopieren Sie die folgende URL für die Beispiel-App und fügen Sie sie in dieses Feld ein: [https://github.com/aws-geospatial/amazon-location-samples-android.git](https://github.com/aws-geospatial/amazon-location-samples-android.git)

1. Entscheiden Sie sich für das Verzeichnis, in das Sie das Repository klonen möchten. Verwenden Sie entweder das Standardverzeichnis oder entscheiden Sie sich für einen benutzerdefinierten Speicherort.

1. Nachdem Sie die Repository-URL und die Verzeichniseinstellungen festgelegt haben, klicken Sie auf die Schaltfläche „Klonen“. Android Studio klont das Repository weiter an den angegebenen Speicherort.

1. Sie haben die Anwendung jetzt auf Ihren Computer geklont und können sie verwenden.

## Verwenden Sie die Beispiel-App
<a name="qs-android-tracking-use"></a>

Gehen Sie wie folgt vor, um das Beispiel zu verwenden:
+ **Erstellen Sie ein `custom.properties`**:

  Gehen Sie folgendermaßen vor, um Ihre `custom.properties` Datei zu konfigurieren:

  1. Öffnen Sie Ihren bevorzugten Texteditor oder Ihre bevorzugte IDE.

  1. Erstellen Sie eine neue Datei.

  1. Speichern Sie die Datei mit dem Namen `custom.properties`.

  1. Aktualisieren Sie das `custom.properties` mit dem folgenden Codebeispiel und ersetzen Sie `MQTT_END_POINT``POLICY_NAME`,`GEOFENCE_COLLECTION_NAME`, und `TOPIC_TRACKER` durch tatsächliche Werte:

     ```
     MQTT_END_POINT=xxxxxxxxxxxxx-xxx.xxx.us-east-1.amazonaws.com
     POLICY_NAME=xxxxxxxxx
     GEOFENCE_COLLECTION_NAME=xxxxxxxxxxxxxxxxx
     TOPIC_TRACKER=xxxxxxxxxx
     ```

  1. Säubern Sie das Projekt und erstellen Sie es neu. Danach können Sie das Projekt ausführen.
+ **Einloggen**:

  Gehen Sie wie folgt vor, um sich bei der Anwendung anzumelden:

  1. Drücken Sie die **Anmeldetaste**.

  1. Geben Sie eine **Identitätspool-ID**, einen **Tracker-Namen** und einen **Kartennamen** an.

  1. Drücken Sie erneut **auf Anmelden**, um den Vorgang abzuschließen.
+ **Filter verwalten**:

  Öffnen Sie den Konfigurationsbildschirm und gehen Sie wie folgt vor:

  1. Schalten Sie die Filter on/off mithilfe der Switch-Benutzeroberfläche um.

  1. Aktualisieren Sie die Zeit- und Entfernungsfilter bei Bedarf.
+ **Vorgänge verfolgen:**

  Öffnen Sie den Tracking-Bildschirm und gehen Sie wie folgt vor:
  + Sie können das Tracking im Vordergrund, Hintergrund oder im Energiesparmodus starten und beenden, indem Sie die entsprechenden Tasten drücken.