As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Autenticação com o Amazon Location Service
<a name="access"></a>

Para usar o Amazon Location Service, um usuário deve ter acesso aos recursos e APIs que compõem o Amazon Location. Há três estratégias que você pode usar o para conceder acesso aos seus recursos.
+ **Use chaves da API**: para conceder acesso a usuários não autenticados, você pode criar chaves da API que dão acesso somente de leitura aos seus recursos e ações do Amazon Location Service. Isso é útil caso você não deseje autenticar todos os usuários. Por exemplo, um aplicativo da web. 

  Para obter mais informações sobre chaves da API, consulte [Usar chaves de API para se autenticar](using-apikeys.md).
+ **Use o Amazon Cognito**: uma alternativa às chaves da API é usar o Amazon Cognito para conceder acesso anônimo. O Amazon Cognito permite que você crie uma autorização mais rica com uma política para definir o que pode ser feito pelos usuários não autenticados. 

  Para obter mais informações sobre como usar o Amazon Cognito, consulte [Usar o Amazon Cognito para autenticação](authenticating-using-cognito.md).
+ **Use o AWS Identity and Access Management (IAM)**: para conceder acesso aos usuários autenticados com Centro de Identidade do AWS IAM ou AWS Identity and Access Management (IAM), crie uma política do IAM que permita o acesso aos recursos que você deseja. 

  Para obter mais informações sobre o IAM e o Amazon Location, consulte [Use AWS Identity and Access Management para autenticar](security-iam.md).

# Escolher um método de autenticação
<a name="choose-method"></a>

As chaves de API e o Amazon Cognito são usados de forma semelhante em cenários semelhantes, então por que você usaria um em vez do outro? A tabela a seguir destaca algumas das principais diferenças entre os dois.
+ **Desempenho:**
  + **Chave de API:** relativamente mais rápido
  + **Amazon Cognito:** relativamente mais lento
+ **Disponibilidade:**
  + **Chave de API:** APIs do Amazon Location para mapas, lugares e rotas
  + **Amazon Cognito:** todas as APIs
+ **Combina com outro método de autenticação? **
  + **Chave de API:** não
  + **Amazon Cognito:** sim

**Comparação**
+ As chaves de API estão disponíveis somente para ações de mapas, lugares e rotas. O Amazon Cognito pode ser usado para autenticar o acesso à maioria das APIs do Amazon Location Service.
+ Geralmente, o desempenho das solicitações de mapas com chaves de API é mais rápido do que cenários semelhantes com o Amazon Cognito. Uma autenticação mais simples significa menos idas e vindas ao serviço e menos solicitações em cache para se obter o mesmo bloco de mapa novamente em um curto período de tempo.
+ Com o Amazon Cognito, você pode usar seu próprio processo de autenticação ou combinar vários métodos de autenticação usando as identidades federadas do Amazon Cognito. 

  Para obter mais informações, consulte [Conceitos básicos das identidades federadas](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html) no Guia do desenvolvedor do Amazon Cognito.

# Usar chaves de API para se autenticar
<a name="using-apikeys"></a>

**nota**  
As chaves de API estão disponíveis para uso somente com recursos de **mapa**, **lugar** e **rota** e você não pode modificar nem criar esses recursos. Se seu aplicativo precisar acessar outros recursos ou ações para usuários não autenticados, você poderá usar o Amazon Cognito para fornecer acesso junto com, ou em vez das, chaves de API. Para obter mais informações, consulte [Usar o Amazon Cognito para autenticação](authenticating-using-cognito.md).

As *chaves de API* são um valor-chave associado a recursos específicos do Amazon Location Service ou API em sua Conta da AWS API e a ações específicas que você pode realizar nesses recursos. Você pode usar uma chave de API em seu aplicativo para fazer chamadas não autenticadas para o Amazon Location APIs para esses recursos. 

Por exemplo, se você associar uma chave de API and/or a um recurso, a `GetPlace*` API, um aplicativo que usa essa chave de API poderá chamar algo específico APIs. Essa mesma chave de API não daria permissões para alterar ou atualizar nenhum recurso ou chamada ao APIs qual não esteja associada.

Quando você liga para o Amazon Location Service APIs em seus aplicativos, você normalmente faz essa chamada como um *usuário autenticado* que está autorizado a fazer as chamadas de API. Contudo, há alguns casos em que não é necessário autenticar todos os usuários da sua aplicação. 

Por exemplo, talvez você queira que um aplicativo da web que mostra a localização da sua empresa esteja disponível para qualquer pessoa que use o site, esteja ela conectada ou não. Nesse caso, uma alternativa é usar as chaves de API para fazer as chamadas de API.

Consulte [Práticas recomendadas da chave de API](#api-keys-best-practices) para obter informações adicionais sobre quando usar chaves de API.

Para obter mais informações sobre como trabalhar com chaves usando a API do Amazon Location Service, consulte os tópicos na *Referência da API do Amazon Location Service*:
+ [CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)
+ [DeleteKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_DeleteKey.html)
+ [DescribeKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_DescribeKey.html)
+ [ListKeys](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_ListKeys.html)

## Criar uma chave de API para o Amazon Location Service
<a name="create-api-key"></a>

Você pode criar uma chave de API por meio do console do Amazon Location Service ou da Amazon Location API. AWS CLI Continue com os procedimentos apropriados abaixo.

------
#### [ Amazon Location console ]

**Para criar uma chave de API usando o console Amazon Location Service**

1. No [https://console.aws.amazon.com/location](https://console.aws.amazon.com/location), selecione **chaves de API** no menu à esquerda.

1. Na página **Chaves de API**, selecione **Criar chave de API**.

1. Na página **Criar chave de API**, preencha as seguintes informações:
   + **Nome**: um nome para sua chave de API, do tipo `ExampleKey`.
   + **Descrição**: uma descrição opcional para a sua chave de API.
   + **Recursos**: no menu suspenso, escolha os recursos do Amazon Location aos quais conceder acesso com essa chave de API. Você pode adicionar mais de um recurso escolhendo **Adicionar recurso**.
   + **Ações**: especifique as ações que você deseja autorizar com essa chave de API. Você deve selecionar pelo menos uma ação para corresponder a cada tipo de recurso selecionado. Por exemplo, se você selecionou um recurso de local, deverá selecionar pelo menos uma das opções em **Ações de locais**.
   + **Prazo**: opcional, adicione uma data e um horário de expiração para sua chave de API. Para obter mais informações, consulte [Práticas recomendadas da chave de API](#api-keys-best-practices).
   + **Restrições de cliente**: opcionalmente, adicione um ou mais domínios da web ou um ou mais aplicações para Android ou Apple nos quais você pode usar a chave de API. Por exemplo, se a chave de API for para permitir que uma aplicação seja executada no site `example.com`, você poderá colocar `*.example.com/` como referenciador permitido.
   + **Tags**: opcional, adicione tags à chave de API.

1. Selecione **Criar chave de API** para criar a chave de API.

1. Na página de detalhes da chave de API, você pode ver informações sobre a chave de API que você criou. Escolha **Mostrar chave de API** para ver o valor da chave que você usa ao chamar a Amazon Location APIs. O valor da chave terá o formato `v1.public.a1b2c3d4...`. 

------
#### [ AWS CLI ]

1. Use o comando [create-key](https://docs.aws.amazon.com/cli/latest/reference/location/create-key.html). O exemplo a seguir cria uma chave de API chamada `ExampleKey` sem data de expiração e acesso a um único recurso de mapa.

   ```
   aws location \
     create-key \
     --key-name ExampleKey \
     --restrictions '{"AllowActions":["geo-maps:*"],"AllowResources":["arn:aws:geo-maps:region::provider/default"]}' \
     --no-expiry
   ```

1. A resposta inclui o valor da chave de API a ser usada ao acessar recursos em seus aplicativos. O valor da chave terá o formato `v1.public.a1b2c3d4...`. Para saber mais sobre como usar a chave de API para renderizar mapas, consulte [Utilizar uma chave de API para chamar uma API do Amazon Location](#using-apikeys-in-api). A resposta para create-key é semelhante à seguinte:

   ```
   {
       "Key": "v1.public.a1b2c3d4...",
       "KeyArn": "arn:aws:geo:region:accountId:api-key/ExampleKey",
       "KeyName": "ExampleKey",
       "CreateTime": "2023-02-06T22:33:15.693Z"
   }
   ```

1. Você também pode usar a `describe-key` para encontrar o valor da chave posteriormente. O exemplo a seguir mostra como chamar `describe-key` em uma chave de API chamada `ExampleKey`.

   ```
   aws location describe-key \
       --key-name ExampleKey
   ```

------
#### [ Amazon Location API ]

Use a [CreateKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_CreateKey.html)operação da Amazon Location APIs. O exemplo a seguir é uma solicitação de API para criar uma chave de API chamada `ExampleKey` sem data de expiração e acesso a um único recurso de mapa.

```
POST /metadata/v0/keys HTTP/1.1
Content-type: application/json
{
  "KeyName": "ExampleKey",
  "NoExpiry": true,
  "Restrictions": {
    "AllowActions": [
      "geo-places:*",
      "geo-routes:*",
      "geo-maps:*"
    ],
    "AllowResources": [
      "arn:aws:geo-places:Region::provider/default",
      "arn:aws:geo-routes:Region::provider/default",
      "arn:aws:geo-maps:Region::provider/default"
    ]
  }
}
```

A resposta inclui o valor da chave de API a ser usada ao acessar recursos em seus aplicativos. O valor da chave terá o formato `v1.public.a1b2c3d4...`.

Você também pode usar a API [DescribeKey](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_DescribeKey.html) para encontrar o valor da chave posteriormente.

------

## Utilizar uma chave de API para chamar uma API do Amazon Location
<a name="using-apikeys-in-api"></a>

Depois de criar uma chave de API, você pode usar o valor da chave para fazer chamadas para a Amazon Location APIs em seu aplicativo.

------
#### [ API ]

As chaves de API APIs que suportam chaves de API têm um parâmetro adicional que usa o valor da chave de API. Por exemplo, se você chamar a API `GetPlace`, você poderá preencher o parâmetro [chave](https://docs.aws.amazon.com/location/latest/APIReference/API_geoplaces_GetPlace.html), da seguinte forma

```
curl --request GET —url 'https://places.geo.eu-central-1.amazonaws.com/v2/place/{PLACEID}?key={APIKEY}&language=jp'
```

------
#### [ AWS CLI ]

Quando você usar o parâmetro `--key`, você também deve usar o parâmetro `--no-sign-request` para evitar assinar com o Sig v4.

```
aws geo-places get-place --place-id $PLACEID --language jp --key $APIKEY
```

------
#### [ SDK (web) ]

Use o seguinte código:

```
<!DOCTYPE html>
<html lang="en">
    <head>
        <title>Display a map</title>
        <meta property="og:description" content="Initialize a map in an HTML element with MapLibre GL JS." />
        <meta charset='utf-8'>
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel='stylesheet' href='https://unpkg.com/maplibre-gl@5.x/dist/maplibre-gl.css' />
        <script src='https://unpkg.com/maplibre-gl@5.x/dist/maplibre-gl.js'></script>
        <style>
            body { margin: 0; }
            #map { height: 100vh; }
        </style>
    </head>
    <body>
         
        <div id="map"></div>
        <script>
     
            const apiKey = "<api key>"; // check how to create api key for Amazon Location
            const mapStyle = "Standard";  // eg. Standard, Monochrome, Hybrid, Satellite  
            const awsRegion = "eu-central-1"; // eg. us-east-2, us-east-1, us-west-2, ap-south-1, ap-southeast-1, ap-southeast-2, ap-northeast-1, ca-central-1, eu-central-1, eu-west-1, eu-west-2, eu-south-2, eu-north-1, sa-east-1
            const styleUrl = `https://maps.geo.${awsRegion}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${apiKey}`;


            const map = new maplibregl.Map({
                container: 'map', // container id
                style: styleUrl, // style URL
                center: [25.24,36.31], // starting position [lng, lat]
                zoom: 2, // starting zoom
            });
        </script>
    </body>
</html>
```

------
#### [ SDK (iOS, Swift) ]

Use o seguinte código:

```
import UIKit
import MapLibre

class ViewController: UIViewController {
    let apiKey = "Enter your API key" // The previously-created API Key to use
    let regionName = "Enter your region name" // The service region - us-east-1, ap-south-1, etc
    var mapView: MLNMapView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        loadMap()
    }
    
    func loadMap() {
        let styleName = "Standard" // The map style - Standard, Monochrome, Hybrid, Satellite
        let colorName = "Light" // The color scheme - Light, Dark
        
        // The Amazon Location Service map style URL that MapLibre will use to render the maps.
        let styleURL = URL(string: "https://maps.geo.\(regionName).amazonaws.com/v2/styles/\(styleName)/descriptor?key=\(apiKey)&color-scheme=\(colorName)")

        // Initialize MapLibre        
        mapView = MLNMapView(frame: view.bounds)
        mapView.styleURL = styleURL
        mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        // Set the starting camera position and zoom level for the map
        mapView.setCenter(CLLocationCoordinate2D(latitude: 49.246559, longitude: -123.063554), zoomLevel: 10, animated: false)
        view.addSubview(mapView!)
    }
}
```

------
#### [ SDK (Android, Kotlin) ]

Use o seguinte código:

```
class MapActivity : Activity(), OnMapReadyCallback {

    private lateinit var mBinding: ActivityMapBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        initializeMap(savedInstanceState)
    }

    private fun initializeMap(savedInstanceState: Bundle?) {
        // Init MapLibre
        // See the MapLibre Getting Started Guide for more details
        // https://maplibre.org/maplibre-native/docs/book/android/getting-started-guide.html
        MapLibre.getInstance(this@MapActivity)
        mBinding = ActivityMapBinding.inflate(layoutInflater)
        setContentView(mBinding.root)
        mBinding.mapView.onCreate(savedInstanceState)
        mBinding.mapView.getMapAsync(this)
    }

    override fun onMapReady(mapLibreMap: MapLibreMap) {
        mapLibreMap.setStyle(Style.Builder().fromUri(getMapUrl())) {
            // Set the starting camera position
            mapLibreMap.cameraPosition = CameraPosition.Builder().target(LatLng(49.246559, -123.063554)).zoom(10.0).build()
            mapLibreMap.uiSettings.isLogoEnabled = false
            mapLibreMap.uiSettings.attributionGravity = Gravity.BOTTOM or Gravity.END
            mapLibreMap.uiSettings.setAttributionDialogManager(AttributionDialogManager(this, mapLibreMap))
        }
    }

    // Return the Amazon Location Service map style URL
    // MapLibre will use this to render the maps.
    // awsRegion: The service region - us-east-1, ap-south-1, etc
    // mapStyle: The map style - Standard, Monochrome, Hybrid, Satellite  
    // API_KEY: The previously-created API Key to use
    // colorName: The color scheme to use - Light, Dark
    private fun getMapUrl() =
           "https://maps.geo.${getString(R.string.awsRegion)}.amazonaws.com/v2/styles/${getString(R.string.mapStyle)}/descriptor?key=${BuildConfig.API_KEY}&color-scheme=${getString(R.string.colorName)}"

    override fun onStart() {
        super.onStart()
        mBinding.mapView.onStart()
    }

    override fun onResume() {
        super.onResume()
        mBinding.mapView.onResume()
    }

    override fun onPause() {
        super.onPause()
        mBinding.mapView.onPause()
    }

    override fun onStop() {
        super.onStop()
        mBinding.mapView.onStop()
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        mBinding.mapView.onSaveInstanceState(outState)
    }

    override fun onLowMemory() {
        super.onLowMemory()
        mBinding.mapView.onLowMemory()
    }

    override fun onDestroy() {
        super.onDestroy()
        mBinding.mapView.onDestroy()
    }
}
```

------

## Restringir o uso da chave de API por origem da solicitação
<a name="restrict-usage-by-origin"></a>

Você pode configurar chaves de API com restrições de cliente que limitam o acesso a domínios ou aplicações móveis específicos. Quando se restringir por domínio, as solicitações serão autorizadas somente se o cabeçalho do indicador HTTP corresponder ao valor fornecido. Quando se restringir por aplicativo Android ou Apple, as solicitações serão autorizadas somente se os campos do cabeçalho do indicador HTTP da aplicação corresponderem aos valores fornecidos por você.

Para obter mais informações, consulte [ApiKeyRestrictions](https://docs.aws.amazon.com/location/latest/APIReference/API_geotags_ApiKeyRestrictions.html)a *Amazon Location Service API Reference*.

**Identificadores de aplicações Android:**
+ `X-Android-Package`:

  Um identificador exclusivo para aplicações Android, definido no arquivo `build.gradle` da aplicação, geralmente seguindo um formato de domínio inverso.

  Exemplo:

  `com.mydomain.appname`
+ `X-Android-Cert`:

  O hash SHA-1 do certificado de assinatura usado para assinar o APK do Android.

  Exemplo:

  `BB:0D:AC:74:D3:21:E1:43:67:71:9B:62:91:AF:A1:66:6E:44:5D:75`

**Identificadores de aplicações da Apple:**
+ `X-Apple-Bundle-Id `:

  Um identificador exclusivo para aplicações Apple (iOS, macOS, etc.), definido no arquivo `Info.plist` da aplicação, geralmente seguindo um formato de domínio reverso.

  Exemplo:

  `com.mydomain.appname`

## Práticas recomendadas da chave de API
<a name="api-keys-best-practices"></a>

As chaves de API incluem um *valor* de texto simples que dá acesso a um ou mais recursos ou APIs ao seu Conta da AWS. Se alguém copiar sua chave de API, poderá acessar esses mesmos recursos APIs e. Para minimizar o impacto potencial, analise as seguintes práticas recomendadas:
+ **Limitar a chave da API**

  Para evitar a situação acima, é melhor limitar sua chave de API. Quando criar a chave, você pode especificar o domínio, a aplicação Android ou Apple em que a chave de API pode ser usada.
+ **Gerencie a vida útil das chaves de API**

  Você pode criar chaves de API que funcionem indefinidamente. No entanto, se você quiser criar uma chave de API temporária, fizer rodízio das chaves de API regularmente ou revogar uma chave de API existente, você pode usar a *expiração da chave de API*.
  + É possível configurar o prazo de validade de uma chave de API ao criá-la ou atualizá-la.
  + Ao atingir o tempo de expiração, a chave de API é desativada automaticamente. As chaves inativas não podem mais ser usadas para fazer solicitações.
  + Você pode alterar uma chave temporária para uma chave permanente removendo o prazo de expiração.
  + Você pode excluir uma chave de API 90 dias após desativá-la.
  + Se tentar desativar uma chave de API que tenha sido usada nos últimos 7 dias, você receberá uma solicitação para confirmar que deseja fazer a alteração. 

    Se você estiver usando a API Amazon Location Service ou a AWS CLI, defina o `ForceUpdate` parâmetro como`true`, caso contrário, você receberá um erro.

# Usar o Amazon Cognito para autenticação
<a name="authenticating-using-cognito"></a>

Você pode usar a autenticação do Amazon Cognito como alternativa ao uso direto de usuários AWS Identity and Access Management (IAM) com solicitações de SDK de front-end. 

O Amazon Cognito fornece autenticação, autorização e gerenciamento de usuários para suas aplicações Web e móveis. Você pode usar grupos de identidade não autenticados do Amazon Cognito com o Amazon Location como uma forma de os aplicativos recuperarem credenciais temporárias com escopo reduzido. AWS 

Para obter mais informações, consulte [Introdução aos Grupos de Usuários](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-user-pools.html) no *Guia do Desenvolvedor do Amazon Cognito*.

Talvez você queira usar essa forma de autenticação pelos seguintes motivos:
+ **Usuários não autenticados**: se você tiver um site com usuários anônimos, poderá usar os bancos de identidades do Amazon Cognito. 

  Para obter mais informações, consulte a seção em [Usar o Amazon Cognito para autenticação](#authenticating-using-cognito). 
+ **Sua própria autenticação**: se você quiser usar seu próprio processo de autenticação ou combinar vários métodos de autenticação, você pode usar as Identidades Federadas do Amazon Cognito. 

  Para obter mais informações, consulte [Conceitos básicos das identidades federadas](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html) no *Guia do desenvolvedor do Amazon Cognito*.

## Usar o Amazon Cognito e o Amazon Location Service
<a name="cognito-and-location"></a>

Você pode usar políticas AWS Identity and Access Management (IAM) associadas a funções de identidade não autenticadas com as seguintes ações:

------
#### [ Maps ]

Lista de ações dos mapas
+ `geo-maps:GetStaticMap`
+ `geo-maps:GetTile`

**nota**  
Os nomes dos recursos para as ações acima são:  

```
arn:aws:geo-maps:region::provider/default
```

------
#### [ Places ]

Lista de ações de locais:
+ `geo-places:Geocode`
+ `geo-places:ReverseGeocode`
+ `geo-places:SearchNearby`
+ `geo-places:SearchText`
+ `geo-places:Autocomplete`
+ `geo-places:Suggest`
+ `geo-places:GetPlace`

**nota**  
Os nomes dos recursos para as ações acima são:  

```
arn:aws:geo-places:region::provider/default
```

------
#### [ Routes ]

Lista de ações de rotas:
+ `geo-routes:CalculateRoutes`
+ `geo-routes:CalculateRouteMatrix`
+ `geo-routes:CalculateIsolines`
+ `geo-routes:OptimizeWaypoints`
+ `geo-routes:SnapToRoads`

**nota**  
Os nomes dos recursos para as ações acima são:  

```
arn:aws:geo-routes:region::provider/default
```

------
#### [ Geofences and Trackers ]

Lista de ações de geocercas e rastreadores
+ `geo:GetGeofence`
+ `geo:ListGeofences`
+ `geo:PutGeofence`
+ `geo:BatchDeleteGeofence`
+ `geo:BatchPutGeofence`
+ `geo:BatchEvaluateGeofences`
+ `geo:GetDevicePosition*`
+ `geo:ListDevicePositions`
+ `geo:BatchDeleteDevicePositionHistory`
+ `geo:BatchGetDevicePosition`
+ `geo:BatchUpdateDevicePosition`

**nota**  
Os nomes dos recursos para as ações acima são:  

```
arn:aws:geo:region:accountID:tracker/ExampleTracker
```

------
#### [ Previous version ]

Lista de ações da versão anterior:
+ `geo:GetMap*`
+ `geo:SearchPlaceIndexForText`
+ `geo:SearchPlaceIndexForPosition`
+ `geo:GetPlace`
+ `geo:CalculateRoute`
+ `geo:CalculateRouteMatrix`

**nota**  
Os nomes dos recursos para as ações acima são:  
**Mapas**  

```
arn:aws:geo:region:accountID:map/ExampleMap
```
**Locais**  

```
arn:aws:geo:region:accountID:place-index/ExamplePlaceIndex
```
**Rotas**  

```
arn:aws:geo:region:accountID:route-calculator/ExampleCalculator
```

------

## Como criar um banco de identidades do Amazon Cognito
<a name="cognito-create-user-pool"></a>

Você pode criar grupos de identidade do Amazon Cognito para permitir o acesso de convidados não autenticados ao seu aplicativo por meio do console do Amazon Cognito, do ou AWS CLI do Amazon Cognito. APIs

**Importante**  
O pool que você cria deve estar na mesma Conta da AWS AWS região dos recursos do Amazon Location Service que você está usando.

------
#### [ Console ]

**Para criar um banco de identidades usando o console do Amazon Cognito**

1. Acesse o [console do Amazon Cognito](https://console.aws.amazon.com/cognito/home).

1. Selecione **Gerenciar grupos de identidades**.

1. Selecione **Criar novo banco de identidades** e, em seguida, insira um nome para seu banco de identidades.

1. Na seção expansível **Identidades não autenticadas**, selecione **Habilitar acesso a identidades não autenticadas**.

1. Selecione **Criar grupo**.

1. Escolha quais perfis do IAM você deseja utilizar com seu banco de identidades.

1. Expanda **Exibir detalhes**. 

1. Em **Identidades não autenticadas**, insira um nome de perfil.

1. Expanda a seção **Exibir documento da política** e selecione **Editar** para adicionar sua política.

1. Adicione sua política para conceder acesso aos seus recursos.
**nota**  
Consulte a seção [Usar o Amazon Cognito e o Amazon Location Service](#cognito-and-location) acima para obter uma lista de ações.

   ```
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
     Sid": "RoutesReadOnly",
     Effect": "Allow",
     Action": [
           // add comma separated value from the previous section
         ],
     Resource": "value from previous section"
       }
     ]
   }
   ```

1. Selecione **Permitir** para criar seus bancos de identidades.

------

## Usar banco de identidades do Amazon Cognito na web
<a name="identity-pool-js"></a>

O exemplo a seguir troca o banco de identidades não autenticado que você criou por credenciais que são então usadas para chamar `CalculateIsolines`. Para simplificar esse trabalho, o exemplo usa os procedimentos de [Como usar auxiliares de autenticação](how-to-auth-helper.md) do Amazon Location Service. Isso serve tanto para obter as credenciais quanto para atualizá-las.

Este exemplo usa o AWS SDK para JavaScript v3.

```
import { GeoRoutesClient, CalculateIsolinesCommand , } from "@aws-sdk/client-geo-routes"; // ES Modules import
import { withIdentityPoolId } from "@aws/amazon-location-utilities-auth-helper";

const identityPoolId = "<identity pool ID>"; // for example, us-east-1:1sample4-5678-90ef-aaaa-1234abcd56ef

const authHelper = await withIdentityPoolId(identityPoolId);

const client = new GeoRoutesClient({
    ...authHelper.getClientConfig(),
    region: "<region>", // The region containing the identity pool
});

const input = {
    DepartNow: true,
    TravelMode: "Car",
    Origin: [-123.12327, 49.27531],
    Thresholds: {
        Time: [5, 10, 30],
    },
};

const command = new CalculateIsolinesCommand(input);
const response = await client.send(command);

console.log(JSON.stringify(response, null, 2))
```

# Use AWS Identity and Access Management para autenticar
<a name="security-iam"></a>





AWS Identity and Access Management (IAM) é uma ferramenta AWS service (Serviço da AWS) que ajuda o administrador a controlar com segurança o acesso aos AWS recursos. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (ter permissões) para utilizar os recursos do Amazon Location. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.

**Topics**
+ [Público](#security_iam_audience)
+ [Autenticação com identidades](#security_iam_authentication)
+ [Gerenciar o acesso usando políticas](#security_iam_access-manage)
+ [Como o Amazon Location Service funciona com o IAM](#security_iam_service-with-iam)
+ [Como o Amazon Location Service funciona com usuários não autenticados](#security_iam_unauthenticated-users)
+ [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples)
+ [Resolução de problemas de identidade e acesso no Amazon Location Service](#security_iam_troubleshoot)

## Público
<a name="security_iam_audience"></a>

A forma como você usa AWS Identity and Access Management (IAM) difere com base na sua função:
+ **Usuário do serviço**: solicite permissões ao seu administrador se você não conseguir acessar os atributos (consulte [Resolução de problemas de identidade e acesso no Amazon Location Service](#security_iam_troubleshoot)).
+ **Administrador do serviço**: determine o acesso do usuário e envie solicitações de permissão (consulte [Como o Amazon Location Service funciona com o IAM](#security_iam_service-with-iam))
+ **Administrador do IAM**: escreva políticas para gerenciar o acesso (consulte [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples))

## Autenticação com identidades
<a name="security_iam_authentication"></a>

A autenticação é a forma como você faz login AWS usando suas credenciais de identidade. Você deve estar autenticado como usuário do IAM ou assumindo uma função do IAM. Usuário raiz da conta da AWS

Você pode fazer login como uma identidade federada usando credenciais de uma fonte de identidade como Centro de Identidade do AWS IAM (IAM Identity Center), autenticação de login único ou credenciais. Google/Facebook Para ter mais informações sobre como fazer login, consulte [Como fazer login em sua Conta da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Guia do usuário do Início de Sessão da AWS *.

Para acesso programático, AWS fornece um SDK e uma CLI para assinar solicitações criptograficamente. Para ter mais informações, consulte [AWS Signature Version 4 para solicitações de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) no *Guia do usuário do IAM*.

### Conta da AWS usuário root
<a name="security_iam_authentication-rootuser"></a>

 Ao criar um Conta da AWS, você começa com uma identidade de login chamada *usuário Conta da AWS raiz* que tem acesso completo a todos Serviços da AWS os recursos. É altamente recomendável não usar o usuário-raiz em tarefas diárias. Consulte as tarefas que exigem credenciais de usuário-raiz em [Tarefas que exigem credenciais de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) no *Guia do usuário do IAM*. 

### Identidade federada
<a name="security_iam_authentication-federated"></a>

Como prática recomendada, exija que os usuários humanos usem a federação com um provedor de identidade para acessar Serviços da AWS usando credenciais temporárias.

Uma *identidade federada* é um usuário do seu diretório corporativo, provedor de identidade da web ou Directory Service que acessa Serviços da AWS usando credenciais de uma fonte de identidade. As identidades federadas assumem funções que oferecem credenciais temporárias.

Para o gerenciamento de acesso centralizado, recomendamos Centro de Identidade do AWS IAM. Para saber mais, consulte [O que é o IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

### Usuários e grupos do IAM
<a name="security_iam_authentication-iamuser"></a>

Um *[usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* é uma identidade com permissões específicas para uma única pessoa ou aplicação. É recomendável usar credenciais temporárias, em vez de usuários do IAM com credenciais de longo prazo. Para obter mais informações, consulte [Exigir que usuários humanos usem a federação com um provedor de identidade para acessar AWS usando credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*.

Um [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica um conjunto de usuários do IAM e facilita o gerenciamento de permissões para grandes conjuntos de usuários. Para ter mais informações, consulte [Casos de uso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) no *Guia do usuário do IAM*.

### Perfis do IAM
<a name="security_iam_authentication-iamrole"></a>

Uma *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade com permissões específicas que oferece credenciais temporárias. Você pode assumir uma função [mudando de um usuário para uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou chamando uma operação de AWS API AWS CLI ou. Para saber mais, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*.

Os perfis do IAM são úteis para acesso de usuário federado, permissões de usuário do IAM temporárias, acesso entre contas, acesso entre serviços e aplicações em execução no Amazon EC2. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.

## Gerenciar o acesso usando políticas
<a name="security_iam_access-manage"></a>

Você controla o acesso AWS criando políticas e anexando-as a AWS identidades ou recursos. Uma política define permissões quando associada a uma identidade ou recurso. AWS avalia essas políticas quando um diretor faz uma solicitação. A maioria das políticas é armazenada AWS como documentos JSON. Para ter mais informações sobre documentos de política JSON, consulte [Visão geral das políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) no *Guia do usuário do IAM*.

Por meio de políticas, os administradores especificam quem tem acesso a que, definindo qual **entidade principal** pode realizar **ações** em quais **recursos** e sob quais **condições**.

Por padrão, usuários e perfis não têm permissões. Um administrador do IAM cria políticas do IAM e as adiciona aos perfis, os quais os usuários podem então assumir. As políticas do IAM definem permissões, independentemente do método usado para realizar a operação.

### Políticas baseadas em identidade
<a name="security_iam_access-manage-id-based-policies"></a>

As políticas baseadas em identidade são documentos de políticas de permissão JSON que você anexa a uma identidade (usuário, grupo ou perfil). Essas políticas controlam quais ações as identidades podem realizar, em quais recursos e sob quais condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*.

As políticas baseadas em identidade podem ser políticas *em linha* (incorporadas diretamente em uma única identidade) ou *políticas gerenciadas* (políticas autônomas anexadas a várias identidades). Para saber como escolher entre uma política gerenciada e políticas em linha, consulte [Escolher entre políticas gerenciadas e políticas em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) no *Guia do usuário do IAM*.

### Políticas baseadas em recursos
<a name="security_iam_access-manage-resource-based-policies"></a>

Políticas baseadas em recursos são documentos de políticas JSON que você anexa a um recurso. Entre os exemplos estão *políticas de confiança de perfil* do IAM e *políticas de bucket* do Amazon S3. Em serviços compatíveis com políticas baseadas em recursos, os administradores de serviço podem usá-las para controlar o acesso a um recurso específico. É necessário [especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) em uma política baseada em recursos.

Políticas baseadas em recursos são políticas em linha localizadas nesse serviço. Você não pode usar políticas AWS gerenciadas do IAM em uma política baseada em recursos.

### Outros tipos de política
<a name="security_iam_access-manage-other-policies"></a>

AWS oferece suporte a tipos de políticas adicionais que podem definir o máximo de permissões concedidas por tipos de políticas mais comuns:
+ **Limites de permissões**: definem o número máximo de permissões que uma política baseada em identidade pode conceder a uma entidade do IAM. Para saber mais sobre limites de permissões, consulte [Limites de permissões para identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) no *Guia do usuário do IAM*.
+ **Políticas de controle de serviço (SCPs)** — Especifique as permissões máximas para uma organização ou unidade organizacional em AWS Organizations. Para saber mais, consulte [Políticas de controle de serviço](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) no *Guia do usuário do AWS Organizations *.
+ **Políticas de controle de recursos (RCPs)** — Defina o máximo de permissões disponíveis para recursos em suas contas. Para obter mais informações, consulte [Políticas de controle de recursos (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) no *Guia AWS Organizations do usuário*.
+ **Políticas de sessão**: políticas avançadas transmitidas como um parâmetro durante a criação de uma sessão temporária para um perfil ou um usuário federado. Para saber mais, consulte [Políticas de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) no *Guia do usuário do IAM*.

### Vários tipos de política
<a name="security_iam_access-manage-multiple-policies"></a>

Quando vários tipos de política são aplicáveis a uma solicitação, é mais complicado compreender as permissões resultantes. Para saber como AWS determinar se uma solicitação deve ser permitida quando vários tipos de políticas estão envolvidos, consulte [Lógica de avaliação de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) no *Guia do usuário do IAM*.

## Como o Amazon Location Service funciona com o IAM
<a name="security_iam_service-with-iam"></a>

Antes de usar o IAM para gerenciar o acesso ao Amazon Location, entenda que atributos do IAM estão disponíveis para uso com o Amazon Location.






**Atributos do IAM que você pode usar com o Amazon Location Service**  

| Recurso do IAM | Suporte do Amazon Location | 
| --- | --- | 
|  [Políticas baseadas em identidade para o Amazon Location](#security_iam_service-with-iam-id-based-policies)  |   Sim  | 
|  [Políticas baseadas em recurso](#security_iam_service-with-iam-resource-based-policies)  |   Não   | 
|  [Ações de políticas](#security_iam_service-with-iam-id-based-policies-actions)  |   Sim  | 
|  [Recursos de políticas](#security_iam_service-with-iam-id-based-policies-resources)  |   Sim  | 
|  [Chaves de condição de política (específicas do serviço)](#security_iam_service-with-iam-id-based-policies-conditionkeys)  |   Sim  | 
|  [ACLs](#security_iam_service-with-iam-acls)  |   Não   | 
|  [ABAC (tags em políticas)](#security_iam_service-with-iam-tags)  |   Sim  | 
|  [Credenciais temporárias](#security_iam_service-with-iam-roles-tempcreds)  |   Sim  | 
|  [Permissões de entidade principal](#security_iam_service-with-iam-principal-permissions)  |   Não   | 
|  [Perfis de serviço](#security_iam_service-with-iam-roles-service)  |   Não   | 
|  [Funções vinculadas ao serviço](#security_iam_service-with-iam-roles-service-linked)  |   Não   | 

Para ter uma visão de alto nível de como o Amazon Location e outros AWS serviços funcionam com a maioria dos recursos do IAM, consulte [AWS os serviços que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.

### Políticas baseadas em identidade para o Amazon Location
<a name="security_iam_service-with-iam-id-based-policies"></a>

**Compatível com políticas baseadas em identidade:** sim

As políticas baseadas em identidade são documentos de políticas de permissões JSON que podem ser anexados a uma identidade, como usuário do IAM, grupo de usuários ou perfil. Essas políticas controlam quais ações os usuários e perfis podem realizar, em quais recursos e em que condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*.

Com as políticas baseadas em identidade do IAM, é possível especificar ações e recursos permitidos ou negados, assim como as condições sob as quais as ações são permitidas ou negadas. Para saber mais sobre todos os elementos que podem ser usados em uma política JSON, consulte [IAM JSON policy elements reference](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) (Referência de elementos da política JSON do IAM) no *Guia do usuário do IAM*.

#### Exemplos de políticas baseadas em identidade para o Amazon Location
<a name="security_iam_service-with-iam-id-based-policies-examples"></a>



Para ver exemplos de políticas baseadas em identidade do Amazon Location, consulte [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples).

### Políticas baseadas em recursos no Amazon Location
<a name="security_iam_service-with-iam-resource-based-policies"></a>

**Compatibilidade com políticas baseadas em recursos:** não 

Políticas baseadas em recursos são documentos de políticas JSON que você anexa a um recurso. São exemplos de políticas baseadas em recursos as *políticas de confiança de perfil* do IAM e as *políticas de bucket* do Amazon S3. Em serviços compatíveis com políticas baseadas em recursos, os administradores de serviço podem usá-las para controlar o acesso a um recurso específico. Para o atributo ao qual a política está anexada, a política define quais ações uma entidade principal especificado pode executar nesse atributo e em que condições. É necessário [especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) em uma política baseada em recursos. Os diretores podem incluir contas, usuários, funções, usuários federados ou. Serviços da AWS

Para permitir o acesso entre contas, é possível especificar uma conta inteira ou as entidades do IAM em outra conta como a entidade principal em uma política baseada em recursos. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.

### Ações de políticas para o Amazon Location
<a name="security_iam_service-with-iam-id-based-policies-actions"></a>

**Compatível com ações de políticas:** sim

Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.

O elemento `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. Incluem ações em uma política para conceder permissões para executar a operação associada.



Para ver uma lista de ações do Amazon Location, consulte [Ações definidas pelo Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-actions-as-permissions) em *Service Authorization Reference* (Referência de autorização do serviço).

As ações de política no Amazon Location usam o seguinte prefixo antes da ação:

```
geo
```

Para especificar várias ações em uma única instrução, separe-as com vírgulas.

```
"Action": [
      "geo:action1",
      "geo:action2"
         ]
```





Você também pode especificar várias ações usando caracteres-curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `Get`, inclua a seguinte ação:

```
"Action": "geo:Get*"
```

Para ver exemplos de políticas baseadas em identidade do Amazon Location, consulte [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples).

### Recursos de políticas para o Amazon Location
<a name="security_iam_service-with-iam-id-based-policies-resources"></a>

**Compatível com recursos de políticas:** sim

Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.

O elemento de política JSON `Resource` especifica o objeto ou os objetos aos quais a ação se aplica. Como prática recomendada, especifique um recurso usando seu [nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Para ações que não oferecem compatibilidade com permissões em nível de recurso, use um curinga (\$1) para indicar que a instrução se aplica a todos os recursos.

```
"Resource": "*"
```

Para ver uma lista dos tipos de recursos de localização da Amazon e seus ARNs, consulte [Resources Defined by Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-resources-for-iam-policies) na *Referência de autorização de serviço*. Para saber com quais ações você pode especificar o ARN de cada recurso, consulte [Actions Defined by Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-actions-as-permissions) (Ações definidas pelo Amazon Location Service).





Para ver exemplos de políticas baseadas em identidade do Amazon Location, consulte [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples).

### Chaves de condição de políticas para o Amazon Location
<a name="security_iam_service-with-iam-id-based-policies-conditionkeys"></a>

**Compatível com chaves de condição de política específicas de serviço:** sim

Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.

O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição AWS globais, consulte as [chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.

Para ver uma lista de chaves de condição do Amazon Location, consulte [Condition Keys for Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-policy-keys) (Chaves de condição do Amazon Location Service) em *Service Authorization Reference* (Referência de autorização do serviço). Para saber com quais ações e recursos você pode usar uma chave de condição, consulte [Actions Defined by Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-actions-as-permissions) (Ações definidas pelo Amazon Location Service).

O Amazon Location é compatível com chaves de condição para permitir ou negar o acesso a geocercas ou dispositivos específicos em suas declarações de política. As seguintes chaves de condição estão disponíveis:
+ `geo:GeofenceIds` para uso com ações de Geocercas. O tipo é `ArrayOfString`.
+ `geo:DeviceIds` para uso com ações do Rastreador. O tipo é `ArrayOfString`.

As ações a seguir podem ser usadas com `geo:GeofenceIds` na sua política do IAM:
+ `BatchDeleteGeofences`
+ `BatchPutGeofences`
+ `GetGeofence`
+ `PutGeofence`

As ações a seguir podem ser usadas com `geo:DeviceIds` na sua política do IAM:
+ `BatchDeleteDevicePositionHistory`
+ `BatchGetDevicePosition`
+ `BatchUpdateDevicePosition`
+ `GetDevicePosition`
+ `GetDevicePositionHistory`

**nota**  
Você não pode usar essas chaves de condição com as ações `BatchEvaluateGeofences`, `ListGeofences`, ou `ListDevicePosition`.

Para ver exemplos de políticas baseadas em identidade do Amazon Location, consulte [Exemplos de políticas baseadas em identidade do Amazon Location Service](#security_iam_id-based-policy-examples).

### ACLs na localização da Amazon
<a name="security_iam_service-with-iam-acls"></a>

**Suportes ACLs:** Não 

As listas de controle de acesso (ACLs) controlam quais diretores (membros da conta, usuários ou funções) têm permissões para acessar um recurso. ACLs são semelhantes às políticas baseadas em recursos, embora não usem o formato de documento de política JSON.

### ABAC com o Amazon Location
<a name="security_iam_service-with-iam-tags"></a>

**Compatível com ABAC (tags em políticas):** sim

O controle de acesso por atributo (ABAC) é uma estratégia de autorização que define permissões com base em atributos chamados de tags. Você pode anexar tags a entidades e AWS recursos do IAM e, em seguida, criar políticas ABAC para permitir operações quando a tag do diretor corresponder à tag no recurso.

Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`.

Se um serviço for compatível com as três chaves de condição para cada tipo de recurso, o valor será **Sim** para o serviço. Se um serviço for compatível com as três chaves de condição somente para alguns tipos de recursos, o valor será **Parcial**

Para saber mais sobre o ABAC, consulte [Definir permissões com autorização do ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) no *Guia do usuário do IAM*. Para visualizar um tutorial com etapas para configurar o ABAC, consulte [Usar controle de acesso por atributo (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) no *Guia do usuário do IAM*.

Para ter mais informações sobre recursos de marcação do Amazon Location, consulte [Como usar marcações](manage-resources.md#manage-resources_how-to).

Para visualizar um exemplo de política baseada em identidade para limitar o acesso a um recurso baseado em tags desse recurso, consulte [Controlar o acesso a recursos com base em tags](#security_iam_tag-based-policy-example).

### Uso de credenciais temporárias com o Amazon Location
<a name="security_iam_service-with-iam-roles-tempcreds"></a>

**Compatível com credenciais temporárias:** sim

As credenciais temporárias fornecem acesso de curto prazo aos AWS recursos e são criadas automaticamente quando você usa a federação ou troca de funções. AWS recomenda que você gere credenciais temporárias dinamicamente em vez de usar chaves de acesso de longo prazo. Para ter mais informações, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) e [Serviços da Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.

### Permissões de entidades principais entre serviços para o Amazon Location
<a name="security_iam_service-with-iam-principal-permissions"></a>

**Compatível com o recurso de encaminhamento de sessões de acesso (FAS):** Não 

 As sessões de acesso direto (FAS) usam as permissões do principal chamando um AWS service (Serviço da AWS), combinadas com a solicitação AWS service (Serviço da AWS) de fazer solicitações aos serviços posteriores. Para obter detalhes da política ao fazer solicitações de FAS, consulte [Sessões de acesso direto](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html). 

### Perfis de serviço para o Amazon Location
<a name="security_iam_service-with-iam-roles-service"></a>

**Compatível com perfis de serviço:** não 

 O perfil de serviço é um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) que um serviço assume para executar ações em seu nome. Um administrador do IAM pode criar, modificar e excluir um perfil de serviço do IAM. Para saber mais, consulte [Criar um perfil para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do Usuário do IAM*. 

**Atenção**  
A alteração das permissões de um perfil de serviço pode interromper a funcionalidade do Amazon Location. Edite perfis de serviço somente quando o Amazon Location fornecer orientação para isso.

### Perfis vinculados ao serviço para o Amazon Location
<a name="security_iam_service-with-iam-roles-service-linked"></a>

**Compatível com perfis vinculados ao serviço:** Não 

 Uma função vinculada ao serviço é um tipo de função de serviço vinculada a um. AWS service (Serviço da AWS) O serviço pode assumir o perfil de executar uma ação em seu nome. As funções vinculadas ao serviço aparecem em você Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço. 

Para obter detalhes sobre como criar ou gerenciar perfis vinculados a serviços, consulte [Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html). Encontre um serviço na tabela que inclua um `Yes` na coluna **Perfil vinculado ao serviço**. Escolha o link **Sim** para visualizar a documentação do perfil vinculado a serviço desse serviço.

## Como o Amazon Location Service funciona com usuários não autenticados
<a name="security_iam_unauthenticated-users"></a>

Muitos cenários para usar o Amazon Location Service, incluindo a exibição de mapas na web ou em um aplicativo móvel, requerem a permissão de acesso a usuários que não tenham feito login com o IAM. Nesses casos não autenticados, você tem duas opções.
+ **Use chaves da API**: para conceder acesso a usuários não autenticados, você pode criar chaves da API que dão acesso somente de leitura aos seus recursos do Amazon Location Service. Isso é útil caso você não deseje autenticar todos os usuários. Por exemplo, um aplicativo da web. Para obter mais informações sobre chaves da API, consulte [Usar chaves de API para se autenticar](using-apikeys.md).
+ **Use o Amazon Cognito**: uma alternativa às chaves da API é usar o Amazon Cognito para conceder acesso anônimo. O Amazon Cognito permite que você crie uma autorização mais rica com uma política do IAM para definir o que pode ser feito pelos usuários não autenticados. Para obter mais informações sobre como usar o Amazon Cognito, consulte [Usar banco de identidades do Amazon Cognito na web](authenticating-using-cognito.md#identity-pool-js).

Para obter uma visão geral sobre como fornecer acesso a usuários não autenticados, consulte [Autenticação com o Amazon Location Service](access.md).

## Exemplos de políticas baseadas em identidade do Amazon Location Service
<a name="security_iam_id-based-policy-examples"></a>

Por padrão, usuários e perfis não têm permissão para criar ou modificar recursos do Amazon Location. Para conceder permissão aos usuários para executar ações nos recursos que eles precisam, um administrador do IAM pode criar políticas do IAM.

Para aprender a criar uma política baseada em identidade do IAM ao usar esses documentos de política em JSON de exemplo, consulte [Criar políticas do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) no *Guia do usuário do IAM*.

Para obter detalhes sobre ações e tipos de recursos definidos pela Amazon Location, incluindo o formato de cada um dos ARNs tipos de recursos, consulte [Actions, Resources, and Condition Keys for Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html) na *Referência de Autorização de Serviço*.

**Topics**
+ [Práticas recomendadas de política](#security_iam_service-with-iam-policy-best-practices)
+ [Usar o console do Amazon Location](#security_iam_id-based-policy-examples-console)
+ [Permitir que os usuários visualizem suas próprias permissões](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Usar os recursos do Amazon Location Service em políticas](#security_iam_id-based-policy-examples-using-resources)
+ [Permissões para atualizar as posições do dispositivo](#security_iam_id-based-policy-examples-update-device-positions)
+ [Política somente leitura para recursos do rastreador](#security_iam_id-based-policy-examples-read-only-trackers)
+ [Política para a criação de geocercas](#security_iam_id-based-policy-examples-create-geofences)
+ [Política somente leitura para geocercas](#security_iam_id-based-policy-examples-read-only-geofences)
+ [Permissões para renderizar um recurso de mapa](#security_iam_id-based-policy-examples-get-map-tiles)
+ [Permissões para operações de pesquisa](#security_iam_id-based-policy-examples-search-for-place)
+ [Política somente leitura para calculadoras de rotas](#security_iam_id-based-policy-examples-calculate-route)
+ [Controlar o acesso aos recursos com base nas chaves de condições](#security_iam_condition-key-example)
+ [Controlar o acesso a recursos com base em tags](#security_iam_tag-based-policy-example)

### Práticas recomendadas de política
<a name="security_iam_service-with-iam-policy-best-practices"></a>

As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir recursos do Amazon Location em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas AWS gerenciadas e avance para as permissões de privilégios mínimos — Para começar a conceder permissões** aos seus usuários e cargas de trabalho, use as *políticas AWS gerenciadas* que concedem permissões para muitos casos de uso comuns. Eles estão disponíveis no seu Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo AWS cliente que sejam específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Você também pode usar condições para conceder acesso às ações de serviço se elas forem usadas por meio de uma ação específica AWS service (Serviço da AWS), como CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA**) — Se você tiver um cenário que exija usuários do IAM ou um usuário root, ative Conta da AWS a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.

Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.

### Usar o console do Amazon Location
<a name="security_iam_id-based-policy-examples-console"></a>

Para acessar o console do Amazon Location Service, você deve ter um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre os recursos de localização da Amazon em seu Conta da AWS. Caso crie uma política baseada em identidade mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para entidades (usuários ou perfis) com essa política.

Você não precisa permitir permissões mínimas do console para usuários que estão fazendo chamadas somente para a API AWS CLI ou para a AWS API. Em vez disso, permita o acesso somente a ações que correspondam à operação de API que estiverem tentando executar.

Para garantir que usuários e perfis ainda possam usar o console do Amazon Location, anexe também a política para as entidades. Para saber mais, consulte [Adicionar permissões a um usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.

A política a seguir dá acesso ao console do Amazon Location Service para poder criar, excluir, listar e visualizar detalhes sobre os recursos de localização do Amazon Location em sua conta AWS .

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

Alternativamente, você pode conceder permissões de somente leitura para facilitar o acesso como somente leitura. Com permissões somente leitura, uma mensagem de erro aparecerá se o usuário tentar escrever ações, como criar ou excluir recursos. Como exemplo, consulte [Política somente leitura para recursos do rastreador](#security_iam_id-based-policy-examples-read-only-trackers)

### Permitir que os usuários visualizem suas próprias permissões
<a name="security_iam_id-based-policy-examples-view-own-permissions"></a>

Este exemplo mostra como criar uma política que permita que os usuários do IAM visualizem as políticas gerenciadas e em linha anexadas a sua identidade de usuário. Essa política inclui permissões para concluir essa ação no console ou programaticamente usando a API AWS CLI ou AWS .

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "ViewOwnUserInfo",
            "Effect": "Allow",
            "Action": [
                "iam:GetUserPolicy",
                "iam:ListGroupsForUser",
                "iam:ListAttachedUserPolicies",
                "iam:ListUserPolicies",
                "iam:GetUser"
            ],
            "Resource": ["arn:aws:iam::*:user/${aws:username}"]
        },
        {
            "Sid": "NavigateInConsole",
            "Effect": "Allow",
            "Action": [
                "iam:GetGroupPolicy",
                "iam:GetPolicyVersion",
                "iam:GetPolicy",
                "iam:ListAttachedGroupPolicies",
                "iam:ListGroupPolicies",
                "iam:ListPolicyVersions",
                "iam:ListPolicies",
                "iam:ListUsers"
            ],
            "Resource": "*"
        }
    ]
}
```

### Usar os recursos do Amazon Location Service em políticas
<a name="security_iam_id-based-policy-examples-using-resources"></a>

O Amazon Location Service usa os seguintes prefixos para recursos:


**Prefixo do recurso do Amazon Location**  

| Recurso | Prefixo do recurso | 
| --- | --- | 
| Recursos de mapa | map | 
| Recursos de local | place-index | 
| Recursos de rota | route-calculator | 
| Recursos de rastreamento | tracker | 
| Recursos da coleção de geocercas | geofence-collection | 

Use a seguinte sintaxe ARN:

```
arn:Partition:geo:Region:Account:ResourcePrefix/ResourceName
```

Para obter mais informações sobre o formato de ARNs, consulte [Amazon Resource Names (ARNs) e AWS Service Namespaces](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html).

**Exemplos**
+ Use o seguinte ARN para permitir o acesso a um recurso de mapa especificado.

  ```
  "Resource": "arn:aws:geo:us-west-2:account-id:map/map-resource-name"
  ```
+ Para especificar o acesso a todos os recursos da `map` que pertencem a uma conta específica, use o caractere curinga (\$1):

  ```
  "Resource": "arn:aws:geo:us-west-2:account-id:map/*"
  ```
+ Algumas ações do Amazon Location, como as que servem para a criação de recursos, não podem ser executadas em um recurso específico. Nesses casos, é necessário utilizar o caractere curinga (\$1).

  ```
  "Resource": "*"
  ```

Para ver uma lista dos tipos de recursos de localização da Amazon e seus ARNs, consulte [Resources Defined by Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-resources-for-iam-policies) na *Referência de autorização de serviço*. Para saber com quais ações você pode especificar o ARN de cada recurso, consulte [Actions Defined by Amazon Location Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlocation.html#amazonlocation-actions-as-permissions) (Ações definidas pelo Amazon Location Service).

### Permissões para atualizar as posições do dispositivo
<a name="security_iam_id-based-policy-examples-update-device-positions"></a>

 Para atualizar as posições do dispositivo para vários rastreadores, você deve conceder a um usuário o acesso a um ou mais dos seus recursos de rastreador. Você também deverá permitir que o usuário atualize um lote de posições do dispositivo.

Neste exemplo, além de conceder acesso aos *Tracker2* recursos *Tracker1* e, a política a seguir concede permissão para usar a `geo:BatchUpdateDevicePosition` ação contra os *Tracker2* recursos *Tracker1* e.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "UpdateDevicePositions",
      "Effect": "Allow",
      "Action": [
        "geo:BatchUpdateDevicePosition"
      ],
      "Resource": [
        "arn:aws:geo:us-west-2:account-id:tracker/Tracker1",
        "arn:aws:geo:us-west-2:account-id:tracker/Tracker2"
      ]
    }
  ]
}
```

Se você quiser limitar o usuário a poder atualizar somente as posições de um dispositivo específico, você pode adicionar uma chave de condição para a ID desse dispositivo.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "UpdateDevicePositions",
      "Effect": "Allow",
      "Action": [
        "geo:BatchUpdateDevicePosition"
      ],
      "Resource": [
        "arn:aws:geo:us-west-2:account-id:tracker/Tracker1",
        "arn:aws:geo:us-west-2:account-id:tracker/Tracker2"
      ],
      "Condition":{
        "ForAllValues:StringLike":{
          "geo:DeviceIds":[
            "deviceId"
          ]
        }
      }
    }
  ]
}
```

### Política somente leitura para recursos do rastreador
<a name="security_iam_id-based-policy-examples-read-only-trackers"></a>

Para criar uma política somente de leitura para todos os recursos do rastreador em sua AWS conta, você precisará conceder acesso a todos os recursos do rastreador. Você também deve conceder ao usuário o acesso a ações que permitam obter a posição do dispositivo para vários dispositivos, obter a posição do dispositivo a partir de um único dispositivo e obter o histórico de posições.

Neste exemplo, a política a seguir concede permissão para as seguintes ações:
+ `geo:BatchGetDevicePosition` para recuperar as posições de vários dispositivos.
+ `geo:GetDevicePosition` para recuperar a posição de um único dispositivo.
+ `geo:GetDevicePositionHistory` para recuperar o histórico de posições de um dispositivo.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "GetDevicePositions",
      "Effect": "Allow",
      "Action": [
        "geo:BatchGetDevicePosition",
        "geo:GetDevicePosition",
        "geo:GetDevicePositionHistory"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:tracker/*"
    }
  ]
}
```

### Política para a criação de geocercas
<a name="security_iam_id-based-policy-examples-create-geofences"></a>

Para criar uma política que permita a um usuário criar geocercas, você precisará conceder acesso a ações específicas que permitam aos usuários criar uma ou mais geocercas em uma coleção de geocercas.

A política abaixo concede permissão para as seguintes ações em*Collection*:
+ `geo:BatchPutGeofence` para criar várias geocercas.
+ `geo:PutGeofence` para criar uma única geocerca.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "CreateGeofences",
      "Effect": "Allow",
      "Action": [
        "geo:BatchPutGeofence",
        "geo:PutGeofence"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:geofence-collection/Collection"
    }
  ]
}
```

### Política somente leitura para geocercas
<a name="security_iam_id-based-policy-examples-read-only-geofences"></a>

Para criar uma política somente leitura para geocercas armazenadas em uma coleção de geocercas na sua conta AWS , você precisará conceder acesso às ações que são lidas da coleção de geocercas que armazena as geocercas.

A política abaixo concede permissão para as seguintes ações em*Collection*:
+ `geo:ListGeofences` para listar geocercas na coleção de geocercas especificada.
+ `geo:GetGeofence` para recuperar uma geocerca da coleção de geocercas.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "GetGeofences",
      "Effect": "Allow",
      "Action": [
        "geo:ListGeofences",
        "geo:GetGeofence"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:geofence-collection/Collection"
    }
  ]
}
```

### Permissões para renderizar um recurso de mapa
<a name="security_iam_id-based-policy-examples-get-map-tiles"></a>

Para conceder permissões suficientes para renderizar mapas, você precisará conceder acesso aos blocos de mapas, “sprites”, glifos e ao descritor de estilo:
+ o `geo:GetMapTile` recupera blocos de mapas usados para renderizar seletivamente os atributos em um mapa.
+ o `geo:GetMapSprites` recupera a planilha de sprites PNG e o documento JSON correspondente, descrevendo os desvios dentro dela.
+ o `geo:GetMapGlyphs` recupera os glifos usados para exibir texto.
+ o `geo:GetMapStyleDescriptor` recupera o descritor de estilo do mapa, contendo regras de renderização.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "GetTiles",
      "Effect": "Allow",
      "Action": [
        "geo:GetMapTile",
        "geo:GetMapSprites",
        "geo:GetMapGlyphs",
        "geo:GetMapStyleDescriptor"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:map/Map"
    }
  ]
}
```

### Permissões para operações de pesquisa
<a name="security_iam_id-based-policy-examples-search-for-place"></a>

Para criar uma política que permita operações de pesquisa, primeiro você precisará conceder acesso ao recurso de índice de lugares em sua AWS conta. Você também deverá conceder acesso a ações que permitam ao usuário pesquisar usando texto por geocodificação e pesquisar usando uma posição por geocodificação reversa.

Neste exemplo, além de conceder acesso a*PlaceIndex*, a política a seguir também concede permissão para as seguintes ações:
+ o `geo:SearchPlaceIndexForPosition` permite que você pesquise lugares ou pontos de interesse próximos a uma determinada posição. 
+ o `geo:SearchPlaceIndexForText` permite que você pesquise um endereço, nome, cidade ou região usando texto em formato livre.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "Search",
      "Effect": "Allow",
      "Action": [
        "geo:SearchPlaceIndexForPosition",
        "geo:SearchPlaceIndexForText"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:place-index/PlaceIndex"
    }
  ]
}
```

### Política somente leitura para calculadoras de rotas
<a name="security_iam_id-based-policy-examples-calculate-route"></a>

Você pode criar uma política somente leitura para permitir que um usuário acesse um recurso de calculadora de rotas para calcular uma rota. 

Neste exemplo, além de conceder acesso a*ExampleCalculator*, a política a seguir concede permissão para a seguinte operação:
+ o `geo:CalculateRoute` calcula uma rota com base em uma posição de partida, posição de destino e uma lista de posições de pontos de referência. 

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "RoutesReadOnly",
      "Effect": "Allow",
      "Action": [
        "geo:CalculateRoute"
      ],
      "Resource": "arn:aws:geo:us-west-2:accountID:route-calculator/ExampleCalculator"
    }
  ]
}
```

### Controlar o acesso aos recursos com base nas chaves de condições
<a name="security_iam_condition-key-example"></a>

Ao criar uma política do IAM para conceder acesso ao uso de geocercas ou posições de dispositivos, você pode usar [operadores de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) para obter um controle mais preciso sobre quais geocercas ou dispositivos um usuário pode acessar. Você pode fazer isso incluindo o ID da geocerca ou o ID do dispositivo no elemento `Condition` da sua política.

O exemplo de política a seguir mostra como você pode criar uma política que permita que um usuário atualize as posições de um dispositivo específico.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "UpdateDevicePositions",
      "Effect": "Allow",
      "Action": [
        "geo:BatchUpdateDevicePosition"
      ],
      "Resource": [
        "arn:aws:geo:us-west-2:account-id:tracker/Tracker"
      ],
      "Condition":{
        "ForAllValues:StringLike":{
          "geo:DeviceIds":[
            "deviceId"
          ]
        }
      }
    }
  ]
}
```

### Controlar o acesso a recursos com base em tags
<a name="security_iam_tag-based-policy-example"></a>

Ao criar uma política do IAM para conceder acesso para usar os recursos do seu Amazon Location, você pode usar o [controle de acesso baseado em atributos](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) para controlar melhor quais recursos um usuário pode modificar, usar ou excluir. Você pode fazer isso incluindo as informações da tag no elemento `Condition` da sua política para controlar o acesso com base nas suas [tags](manage-resources.md#manage-resources_how-to) de recursos.

O exemplo de política a seguir mostra como você pode criar uma política que permita que um usuário crie geocercas. Isso concede a permissão às seguintes ações para criar uma ou mais cercas geográficas em uma coleção de cercas geográficas chamada: *Collection*
+ `geo:BatchPutGeofence` para criar várias geocercas.
+ `geo:PutGeofence` para criar uma única geocerca.

No entanto, essa política usa o `Condition` elemento para conceder a permissão somente se a *Collection* tag,`Owner`, tiver o valor do nome de usuário desse usuário. 
+ Por exemplo, se um usuário chamado `richard-roe` tentar visualizar uma localização da Amazon*Collection*, ela *Collection* deverá ser marcada como `Owner=richard-roe` ou`owner=richard-roe`. Caso contrário, o usuário terá o acesso negado. 
**nota**  
A chave da tag de condição `Owner` corresponde a `Owner` e a `owner` porque os nomes das chaves de condição não fazem distinção entre maiúsculas e minúsculas. Para obter mais informações, consulte [IAM JSON Policy Elements: Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) (Elementos da política JSON do IAM: Condição) no *Guia do usuário do IAM*.

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "CreateGeofencesIfOwner",
      "Effect": "Allow",
      "Action": [
        "geo:BatchPutGeofence",
        "geo:PutGeofence"
      ],
      "Resource": "arn:aws:geo:us-west-2:account-id:geofence-collection/Collection",
      "Condition": {
                "StringEquals": {"geo:ResourceTag/Owner": "${aws:username}"}
      }
    }
  ]
}
```

Para ver um tutorial sobre [como definir permissões para acessar recursos da AWS com base em tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html), consulte o *Guia do usuário do AWS Identity and Access Management *.

## Resolução de problemas de identidade e acesso no Amazon Location Service
<a name="security_iam_troubleshoot"></a>

Use as informações a seguir para diagnosticar e corrigir problemas comuns que você pode encontrar ao trabalhar com o Amazon Location e o IAM.

**Topics**
+ [Não tenho autorização para executar uma ação no Amazon Location](#security_iam_troubleshoot-no-permissions)
+ [Não estou autorizado a realizar iam: PassRole](#security_iam_troubleshoot-passrole)
+ [Quero permitir que pessoas de fora da minha Conta da AWS acessem meus recursos de localização da Amazon](#security_iam_troubleshoot-cross-account-access)

### Não tenho autorização para executar uma ação no Amazon Location
<a name="security_iam_troubleshoot-no-permissions"></a>

Se você receber uma mensagem de erro informando que não tem autorização para executar uma ação, suas políticas deverão ser atualizadas para permitir que você realize a ação.

O erro do exemplo a seguir ocorre quando o usuário do IAM `mateojackson` tenta usar o console para visualizar detalhes sobre um atributo `my-example-widget` fictício, mas não tem as permissões `geo:GetWidget` fictícias.

```
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: geo:GetWidget on resource: my-example-widget
```

Nesse caso, a política do usuário `mateojackson` deve ser atualizada para permitir o acesso ao recurso `my-example-widget` usando a ação `geo:GetWidget`.

Se precisar de ajuda, entre em contato com seu AWS administrador. Seu administrador é a pessoa que forneceu suas credenciais de login.

### Não estou autorizado a realizar iam: PassRole
<a name="security_iam_troubleshoot-passrole"></a>

Caso receba uma mensagem de erro informando que você não tem autorização para executar a ação `iam:PassRole`, as suas políticas deverão ser atualizadas para permitir que você atribua um perfil ao Amazon Location.

Alguns Serviços da AWS permitem que você passe uma função existente para esse serviço em vez de criar uma nova função de serviço ou uma função vinculada ao serviço. Para fazer isso, é preciso ter permissões para passar o perfil para o serviço.

O erro exemplificado a seguir ocorre quando uma usuária do IAM chamada `marymajor` tenta usar o console para executar uma ação no Amazon Location. No entanto, a ação exige que o serviço tenha permissões concedidas por um perfil de serviço. Mary não tem permissões para passar o perfil para o serviço.

```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```

Nesse caso, as políticas de Mary devem ser atualizadas para permitir que ela realize a ação `iam:PassRole`.

Se precisar de ajuda, entre em contato com seu AWS administrador. Seu administrador é a pessoa que forneceu suas credenciais de login.

### Quero permitir que pessoas de fora da minha Conta da AWS acessem meus recursos de localização da Amazon
<a name="security_iam_troubleshoot-cross-account-access"></a>

É possível criar um perfil que os usuários de outras contas ou pessoas fora da organização podem usar para acessar seus recursos. É possível especificar quem é confiável para assumir o perfil. Para serviços que oferecem suporte a políticas baseadas em recursos ou listas de controle de acesso (ACLs), você pode usar essas políticas para conceder às pessoas acesso aos seus recursos.

Para saber mais, consulte:
+ Para saber se o Amazon Location é compatível com esses recursos, consulte [Como o Amazon Location Service funciona com o IAM](#security_iam_service-with-iam).
+ Para saber como fornecer acesso aos seus recursos em todos os Contas da AWS que você possui, consulte Como [fornecer acesso a um usuário do IAM em outro Conta da AWS que você possui](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no *Guia do usuário do IAM*.
+ Para saber como fornecer acesso aos seus recursos a terceiros Contas da AWS, consulte Como [fornecer acesso Contas da AWS a terceiros](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) no *Guia do usuário do IAM*.
+ Para saber como conceder acesso por meio da federação de identidades, consulte [Conceder acesso a usuários autenticados externamente (federação de identidades)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) no *Guia do usuário do IAM*.
+ Para conhecer a diferença entre perfis e políticas baseadas em recurso para acesso entre contas, consulte [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.