Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Comment utiliser les aides à l'authentification
<a name="how-to-auth-helper"></a>

Cette section fournit des informations supplémentaires sur les aides à l'authentification.

## Web
<a name="loc-sdk-auth-web"></a>

Les utilitaires JavaScript d'authentification Amazon Location facilitent l'authentification lorsque vous effectuez des appels d'API Amazon Location Service depuis des JavaScript applications. Ces utilitaires prennent spécifiquement en charge l'authentification à l'aide de clés d'API ou d'Amazon Cognito.

**Installation**
+ Installez cette bibliothèque à l'aide de NPM :

  ```
  npm install @aws/amazon-location-utilities-auth-helper
  ```
+ Pour l'utiliser directement dans le navigateur, incluez les éléments suivants dans votre fichier HTML :

  ```
  <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
  ```

### Usage
<a name="loc-sdk-auth-usage"></a>

Pour utiliser les aides à l'authentification, importez la bibliothèque et appelez les fonctions utilitaires nécessaires. Cette bibliothèque prend en charge l'authentification des demandes provenant d'Amazon Location Service SDKs, y compris les demandes autonomes [Maps](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-maps/), [Places](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-places/) et [Routes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/geo-routes/) SDKs, ainsi que le rendu de cartes avec [MapLibre GL](https://github.com/maplibre/maplibre-gl-js) JS.

**Utilisation avec les modules**

Cet exemple illustre l'utilisation du SDK Places autonome pour effectuer une demande authentifiée à l'aide de clés d'API :

```
npm install @aws-sdk/client-geo-places

import { GeoPlacesClient, GeocodeCommand } from "@aws-sdk/client-geo-places";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new GeoPlacesClient(authHelper.getClientConfig());

const input = { ... };
const command = new GeocodeCommand(input);
const response = await client.send(command);
```

Cet exemple illustre l'utilisation du SDK Routes autonome pour effectuer une demande authentifiée à l'aide de clés d'API :

```
npm install @aws-sdk/geo-routes-client

import { GeoRoutesClient, CalculateRoutesCommand } from "@aws-sdk/geo-routes-client";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new GeoRoutesClient(authHelper.getClientConfig());

const input = { ... };
const command = new CalculateRoutesCommand(input);
const response = await client.send(command);
```

Cet exemple utilise le SDK de localisation avec authentification par clé d'API :

```
npm install @aws-sdk/client-location

import { LocationClient, ListGeofencesCommand } from "@aws-sdk/client-location";
import { withAPIKey } from "@aws/amazon-location-utilities-auth-helper";

const authHelper = withAPIKey("<API Key>", "<Region>");
const client = new LocationClient(authHelper.getClientConfig());

const input = { ... };
const command = new ListGeofencesCommand(input);
const response = await client.send(command);
```

**Utilisation avec le navigateur**

Les fonctions utilitaires sont accessibles sous l'objet global amazonLocationAuth Helper lorsqu'elles sont utilisées directement dans un environnement de navigateur.

Cet exemple illustre une demande auprès du client Amazon Location, authentifiée à l'aide de clés d'API :

```
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1"></script>

const authHelper = amazonLocationClient.withAPIKey("<API Key>", "<Region>");
const client = new amazonLocationClient.GeoRoutesClient(authHelper.getClientConfig());
const input = { ... };
const command = new amazonLocationClient.routes.CalculateRoutesCommand(input);
const response = await client.send(command);
```

Cet exemple illustre le rendu d'une carte avec MapLibre GL JS, authentifiée à l'aide d'une clé d'API :

```
<script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x"></script>

const apiKey = "<API Key>";
const region = "<Region>";
const styleName = "Standard";

const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${styleName}/descriptor?key=${apiKey}`,
});
```

Cet exemple illustre le rendu d'une carte avec MapLibre GL JS à l'aide d'Amazon Cognito :

```
<script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x"></script>
<script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>

const identityPoolId = "<Identity Pool ID>";
const authHelper = await amazonLocationAuthHelper.withIdentityPoolId(identityPoolId);

const map = new maplibregl.Map({
  container: "map",
  center: [-123.115898, 49.295868],
  zoom: 10,
  style: `https://maps.geo.${region}.amazonaws.com/v2/styles/${styleName}/descriptor`,
  ...authHelper.getMapAuthenticationOptions(),
});
```

**Utilisation alternative avec des identités authentifiées**

Vous pouvez modifier la fonction withIdentityPool Id pour inclure des paramètres personnalisés pour les identités authentifiées :

```
const userPoolId = "<User Pool ID>";

const authHelper = await amazonLocationAuthHelper.withIdentityPoolId(identityPoolId, {
  logins: {
    [`cognito-idp.${region}.amazonaws.com/${userPoolId}`]: "cognito-id-token"
  }
});
```

## iOS
<a name="loc-sdk-auth-ios"></a>

Le SDK Amazon Location Service Mobile Authentication pour iOS permet d'authentifier les demandes adressées à Amazon Location Service à APIs partir d'applications iOS. Il prend spécifiquement en charge l'authentification via des clés d'API ou Amazon Cognito.

**Installation**
+ Ouvrez Xcode et accédez à **Fichier > Ajouter des dépendances de package**.
+ Tapez l'URL du package ([https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/](https://github.com/aws-geospatial/amazon-location-mobile-auth-sdk-ios/)) dans la barre de recherche et appuyez sur Entrée.
+ **Sélectionnez le package « amazon-location-mobile-auth -sdk-ios » et cliquez sur Ajouter un package.**
+ Choisissez le package « AmazonLocationi OSAuth SDK » et cliquez sur **Ajouter un package**.

### Usage
<a name="loc-sdk-auth-usage"></a>

Après avoir installé la bibliothèque, utilisez la `AuthHelper` classe pour configurer les paramètres du client pour les clés d'API ou pour Amazon Cognito.

**Clés d'API**

Voici un exemple d'utilisation du SDK Places autonome avec authentification par clé d'API :

```
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

func geoPlacesExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: GeoPlacesClient = GeoPlacesClient(config: authHelper.getGeoPlacesClientConfig())

    let input = AWSGeoPlaces.SearchTextInput(
        biasPosition: [-97.7457518, 30.268193],
        queryText: "tacos"
    )

    let output = try await client.searchText(input: input)
}
```

Voici un exemple d'utilisation du SDK Routes autonome avec authentification par clé d'API :

```
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

func geoRoutesExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: GeoRoutesClient = GeoRoutesClient(config: authHelper.getGeoRoutesClientConfig())

    let input = AWSGeoRoutes.CalculateRoutesInput(
        destination: [-123.1651031, 49.2577281],
        origin: [-97.7457518, 30.268193]
    )

    let output = try await client.calculateRoutes(input: input)
}
```

Voici un exemple d'utilisation du SDK de localisation avec authentification par clé d'API :

```
import AmazonLocationiOSAuthSDK
import AWSLocation

func locationExample() {
    let apiKey = "<API key>"
    let region = "<Region>"

    let authHelper = try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    let client: LocationClient = LocationClient(config: authHelper.getLocationClientConfig())

    let input = AWSLocation.ListGeofencesInput(
        collectionName: "<Collection name>"
    )

    let output = try await client.listGeofences(input: input)
}
```

Voici un exemple d'utilisation du SDK Places autonome avec Amazon Cognito :

```
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

func geoPlacesExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: GeoPlacesClient = GeoPlacesClient(config: authHelper.getGeoPlacesClientConfig())

    let input = AWSGeoPlaces.SearchTextInput(
        biasPosition: [-97.7457518, 30.268193],
        queryText: "tacos"
    )

    let output = try await client.searchText(input: input)
}
```

Voici un exemple d'utilisation du SDK Routes autonome avec Amazon Cognito :

```
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

func geoRoutesExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: GeoRoutesClient = GeoRoutesClient(config: authHelper.getGeoRoutesClientConfig())

    let input = AWSGeoRoutes.CalculateRoutesInput(
        destination: [-123.1651031, 49.2577281],
        origin: [-97.7457518, 30.268193]
    )

    let output = try await client.calculateRoutes(input: input)
}
```

Voici un exemple d'utilisation du SDK de localisation avec Amazon Cognito :

```
import AmazonLocationiOSAuthSDK
import AWSLocation

func locationExample() {
    let identityPoolId = "<Identity Pool ID>"

    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)
    let client: LocationClient = LocationClient(config: authHelper.getLocationClientConfig())

    let input = AWSLocation.ListGeofencesInput(
        collectionName: "<Collection name>"
    )

    let output = try await client.listGeofences(input: input)
}
```

## Android
<a name="loc-sdk-auth-android"></a>

Le SDK Amazon Location Service Mobile Authentication pour Android vous aide à authentifier les demandes adressées à Amazon Location APIs Service à partir d'applications Android, en prenant notamment en charge l'authentification à l'aide d'Amazon Cognito.

**Installation**
+ Ce SDK d'authentification fonctionne avec l'ensemble du SDK AWS Kotlin. Les deux SDKs sont publiés sur Maven Central. Vérifiez la dernière version du [SDK d'authentification](https://mvnrepository.com/artifact/software.amazon.location/auth) sur Maven Central.
+ Ajoutez les lignes suivantes à la section des dépendances de votre `build.gradle` fichier dans Android Studio :

  ```
  implementation("software.amazon.location:auth:1.1.0")
  implementation("org.maplibre.gl:android-sdk:11.5.2")
  implementation("com.squareup.okhttp3:okhttp:4.12.0")
  ```
+ Pour les cartes, lieux et itinéraires autonomes SDKs, ajoutez les lignes suivantes :

  ```
  implementation("aws.sdk.kotlin:geomaps:1.3.65")
  implementation("aws.sdk.kotlin:geoplaces:1.3.65")
  implementation("aws.sdk.kotlin:georoutes:1.3.65")
  ```
+ Pour le SDK de localisation consolidé qui inclut le géofencing et le suivi, ajoutez la ligne suivante :

  ```
  implementation("aws.sdk.kotlin:location:1.3.65")
  ```

### Usage
<a name="loc-sdk-auth-usage"></a>

Importez les classes suivantes dans votre code :

```
// For the standalone Maps, Places, and Routes SDKs
import aws.sdk.kotlin.services.geomaps.GeoMapsClient
import aws.sdk.kotlin.services.geoplaces.GeoPlacesClient
import aws.sdk.kotlin.services.georoutes.GeoRoutesClient

// For the consolidated Location SDK
import aws.sdk.kotlin.services.location.LocationClient

import software.amazon.location.auth.AuthHelper
import software.amazon.location.auth.LocationCredentialsProvider
import software.amazon.location.auth.AwsSignerInterceptor
import org.maplibre.android.module.http.HttpRequestUtil
import okhttp3.OkHttpClient
```

Vous pouvez créer un `AuthHelper` et l'utiliser avec le SDK AWS Kotlin :

**Exemple : fournisseur d'informations d'identification avec ID de pool d'identités**

```
private suspend fun exampleCognitoLogin() {
    val authHelper = AuthHelper.withCognitoIdentityPool("MY-COGNITO-IDENTITY-POOL-ID", applicationContext)
    
    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

**Exemple : fournisseur d'informations d'identification avec fournisseur d'informations d'identification personnalisé**

```
private suspend fun exampleCustomCredentialLogin() {
    var authHelper = AuthHelper.withCredentialsProvider(MY-CUSTOM-CREDENTIAL-PROVIDER, "MY-AWS-REGION", applicationContext)

    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

**Exemple : fournisseur d'informations d'identification avec clé d'API**

```
private suspend fun exampleApiKeyLogin() {
    var authHelper = AuthHelper.withApiKey("MY-API-KEY", "MY-AWS-REGION", applicationContext)

    var geoMapsClient = GeoMapsClient(authHelper?.getGeoMapsClientConfig())
    var geoPlacesClient = GeoPlacesClient(authHelper?.getGeoPlacesClientConfig())
    var geoRoutesClient = GeoRoutesClient(authHelper?.getGeoRoutesClientConfig())
    
    var locationClient = LocationClient(authHelper?.getLocationClientConfig())
}
```

Vous pouvez l'utiliser `LocationCredentialsProvider` pour charger la MapLibre carte. Voici un exemple :

```
HttpRequestUtil.setOkHttpClient(
    OkHttpClient.Builder()
        .addInterceptor(
            AwsSignerInterceptor(
                "geo",
                "MY-AWS-REGION",
                locationCredentialsProvider,
                applicationContext
            )
        )
        .build()
)
```

Utilisez les clients créés pour passer des appels vers Amazon Location Service. Voici un exemple qui recherche des lieux proches d'une latitude et d'une longitude spécifiées :

```
val suggestRequest = SuggestRequest {
       biasPosition = listOf(-97.718833, 30.405423)
       maxResults = MAX_RESULT
       language = "PREFERRED-LANGUAGE"
   }
val nearbyPlaces = geoPlacesClient.suggest(suggestRequest)
```