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

# Usando o AWS AppSync Private APIs
<a name="using-private-apis"></a>

Se você usa a Amazon Virtual Private Cloud (Amazon VPC), você pode criar AWS AppSync Private APIs, que só pode ser acessada de uma VPC. APIs Com uma API privada, você pode restringir o acesso da API aos seus aplicativos internos e conectar-se aos endpoints GraphQL e Realtime sem expor os dados publicamente.

Para estabelecer uma conexão privada entre sua VPC e o AWS AppSync serviço, você deve criar endpoints de VPC de interface. Os endpoints de interface são alimentados por [AWS PrivateLink](https://aws.amazon.com/privatelink), o que permite que você acesse de forma privada AWS AppSync APIs sem um gateway de internet, dispositivo NAT, conexão VPN ou conexão. Direct Connect As instâncias em sua VPC não precisam de endereços IP públicos para se comunicar. AWS AppSync APIs Tráfego entre sua VPC e o tráfego AWS AppSync que não sai da AWS rede.

AWS AppSync suportes AWS PrivateLink para operações de plano de dados e plano de controle:
+ **Data plane endpoint** (`com.amazonaws.{region}.appsync-api`): fornece acesso privado ao seu GraphQL e APIs em tempo real para consultas, mutações e assinaturas.
+ **Ponto final do plano de controle** (`com.amazonaws.{region}.appsync`): fornece acesso privado às operações AWS AppSync de gerenciamento, como criar APIs, atualizar esquemas e configurar fontes de dados.

![\[Nuvem AWS architecture showing VPC with public and private subnets connecting to AWS AppSync via PrivateLink.\]](http://docs.aws.amazon.com/pt_br/appsync/latest/devguide/images/private-api-architecture.png)


Há alguns fatores adicionais a serem considerados antes de ativar os atributos da API privada:
+ Configurar endpoints de interface VPC AWS AppSync com recursos de DNS privado habilitados impedirá que recursos na VPC possam invocar outros AWS AppSync públicos usando o URL da API gerado. APIs AWS AppSync Isso se deve ao fato de a solicitação à API pública ser roteada por meio do endpoint da interface, o que não é permitido para o público. APIs Para invocar public APIs nesse cenário, é recomendável configurar nomes de domínio personalizados em public APIs, que podem ser usados por recursos na VPC para invocar a API pública. 
+ Seu AWS AppSync Private só APIs estará disponível em sua VPC. O editor de consultas do AWS AppSync console só poderá acessar sua API se a configuração de rede do seu navegador puder rotear o tráfego para sua VPC (por exemplo, conexão via VPN ou mais Direct Connect).
+ Com um endpoint de interface VPC para AWS AppSync, você pode acessar qualquer API privada na mesma AWS conta e região. Para restringir ainda mais o acesso ao Privado APIs, você pode considerar as seguintes opções:
  + Garantindo que somente os administradores necessários possam criar interfaces de endpoint VPC para. AWS AppSync
  + Usando políticas personalizadas de VPC endpoint para restringir o que APIs pode ser invocado a partir de recursos na VPC. 
  + Para recursos na VPC, recomendamos que você use a autorização do IAM para invocar, AWS AppSync APIs garantindo que os recursos recebam funções com escopo reduzido para o. APIs
+ Ao criar ou usar políticas que restringem as entidades principais do IAM, você deve definir o `authorizationType` do método como `AWS_IAM` ou `NONE`.

## Criação de AWS AppSync dados privados APIs
<a name="creating-private-apis"></a>

As etapas a seguir mostram como criar Privado APIs no AWS AppSync serviço.

**Atenção**  
Você pode ativar os atributos da API privada somente durante a criação da API. Essa configuração não pode ser modificada em uma AWS AppSync API ou em uma API AWS AppSync privada após sua criação.

1. Faça login no Console de gerenciamento da AWS e abra o [AppSync console](https://console.aws.amazon.com/appsync/).

   1. No **Painel**, escolha **Criar API**.

1. Escolha **Criar uma API do zero** e, em seguida, escolha **Avançar**.

1. Na seção **API privada**, escolha **Usar atributos da API privada**.

1. Configure o restante das opções, revise os dados da API e escolha **Criar**.

Antes de usar sua API AWS AppSync privada, você deve configurar endpoints de interface para AWS AppSync sua VPC. Observe que tanto a API privada quanto a VPC devem estar na mesma AWS conta e região.

## Criação de endpoints de interface para AWS AppSync
<a name="creating-interface-endpoint"></a>

Você pode criar endpoints de interface para AWS AppSync usar o console Amazon VPC ou AWS Command Line Interface o AWS CLI(). Dependendo do caso de uso, talvez você precise criar um ou ambos os tipos de endpoint:
+ **Endpoint do plano de dados**: necessário para acessar o Private a APIs partir de sua VPC
+ **Endpoint do plano de controle**: necessário para gerenciar AWS AppSync recursos de sua VPC usando o ou AWS CLI SDKs

Para obter mais informações, consulte [Criar um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) no *Guia do usuário da Amazon VPC*.

**nota**  
Certifique-se de selecionar o serviço de endpoint de VPC correto; há dois para AppSync: `com.amazonaws.{region}.appsync-api` é o necessário para privado e o usado para APIs gerenciamento `com.amazonaws.{region}.appsync` de API.

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

1. Faça login Console de gerenciamento da AWS e abra a página [Endpoints](https://console.aws.amazon.com/vpc/home?#Endpoints) do console Amazon VPC.

1. Escolha **Criar endpoint**.

   1. No campo **Categoria de serviço**, verifique se a opção **Serviços da AWS ** está selecionada.

   1. Na tabela **Serviços**, escolha um dos seguintes serviços:
      + Para acesso do plano de dados: `com.amazonaws.{region}.appsync-api`
      + Para acesso do ambiente de gerenciamento: `com.amazonaws.{region}.appsync`

      Verifique se o valor da coluna **Tipo** é `Interface`.

   1. No campo **VPC**, escolha uma VPC e suas sub-redes.

   1. Para habilitar os atributos do DNS privado para o endpoint da interface, marque a caixa de seleção **Habilitar nome de DNS**.

   1. Em **Grupo de segurança**, selecione um ou mais grupos de segurança.

1. Escolha **Criar endpoint**.

1. Repita o processo para criar o segundo tipo de endpoint, se necessário.

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

Use o comando `[create-vpc-endpoint](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html)` e especifique o ID da VPC, o tipo de endpoint da VPC (interface), o nome do serviço, as sub-redes que usarão o endpoint e os grupos de segurança associados às interfaces de rede do endpoint.

**Crie um endpoint do plano de dados:**

```
$ aws ec2 create-vpc-endpoint —vpc-id vpc-ec43eb89 \
  —vpc-endpoint-type Interface \
  —service-name com.amazonaws.{region}.appsync-api \
  —subnet-id subnet-abababab —security-group-id sg-1a2b3c4d
```

**Crie um endpoint do ambiente de gerenciamento:**

```
$ aws ec2 create-vpc-endpoint —vpc-id vpc-ec43eb89 \
  —vpc-endpoint-type Interface \
  —service-name com.amazonaws.{region}.appsync \
  —subnet-id subnet-abababab —security-group-id sg-1a2b3c4d
```

------

Para usar a opção de DNS privado, defina os valores `enableDnsHostnames` e `enableDnsSupportattributes` da VPC. Para obter mais informações, consulte [Ver e atualizar o suporte do DNS para a VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) no *Manual do usuário da Amazon VPC*. Se você habilitar recursos de DNS privados para o endpoint da interface, poderá fazer solicitações à sua API AWS AppSync GraphQL e ao endpoint em tempo real usando seus endpoints DNS públicos padrão usando o formato abaixo:

```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```

Para operações do plano de controle, você pode usar o endpoint AWS AppSync de serviço padrão:

```
https://appsync.{region}.amazonaws.com
```

Para obter mais informações sobre endpoints de serviço, consulte [Endpoints de serviço e cotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) na *Referência geral do AWS *.

Para obter mais informações sobre interações de serviço com endpoints da interface, consulte [Acessar um serviço por um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) no *Guia do usuário da Amazon VPC*.

*Para obter informações sobre como criar e configurar um endpoint usando AWS CloudFormation, consulte o VPCEndpoint recurso [AWS: :EC2::](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) no Guia do usuário.AWS CloudFormation *

## Exemplos avançados
<a name="advanced-example"></a>

Se você habilitar recursos de DNS privados para o endpoint da interface, poderá fazer solicitações à sua API AWS AppSync GraphQL e ao endpoint em tempo real usando seus endpoints DNS públicos padrão usando o formato abaixo:

```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```

Usando os nomes de host de DNS público do endpoint da VPC da interface, o URL de base para invocar a API estará neste formato:

```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql
```

Você também pode usar o nome de host de DNS específico do AZ se tiver implantado um endpoint no AZ:

```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}-{az_id}.appsync-api.{region}.vpce.amazonaws.com/graphql.
```

Usar o nome DNS público do VPC endpoint exigirá que o nome do host do endpoint da AWS AppSync API seja passado como cabeçalho para a `Host` solicitação. ` x-appsync-domain` Esses exemplos usam um `TodoAPI` que foi criado no guia [Iniciar esquema de amostra](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html):

```
curl https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-H "Host:{api_url_identifier}.appsync-api.{region}.amazonaws.com" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```

Nos exemplos a seguir, usaremos o aplicativo *Todo* que é gerado no guia [Iniciar esquema de amostra](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html). Para testar a amostra da API Todo, usaremos o DNS privado para invocar a API. Você pode usar qualquer ferramenta de linha de comando de sua escolha; este exemplo usa [curl](https://curl.se/) para enviar consultas e mutações e [wscat](https://www.npmjs.com/package/wscat) para configurar assinaturas. Para emular nosso exemplo, substitua os valores entre colchetes `{ }` nos comandos abaixo pelos valores correspondentes da sua AWS conta.

**Operação de mutação de teste — Solicitação do `createTodo`**

```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```

**Operação de mutação de teste — Resposta do `createTodo`**

```
{
    "data": {
        "createTodo": {
            "id": "<todo-id>",
            "name": "My first GraphQL task",
            "where": "Day 1",
            "when": "Friday Night",
            "description": "Learn more about GraphQL"
        }
    }
}
```

**Operação de consulta de teste — Solicitação do `listTodos`**

```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"query ListTodos {\n listTodos {\n items {\n description\n id\n name\n when\n where\n }\n }\n}\n","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```

**Operação de consulta de teste — Solicitação do `listTodos`**

```
{
  "data": {
    "listTodos": {
      "items": [
        {
          "description": "Learn more about GraphQL",
          "id": "<todo-id>",
          "name": "My first GraphQL task",
          "when": "Friday night",
          "where": "Day 1"
        }
      ]
    }
  }
}
```

**Operação de assinatura de teste — Assinatura para a mutação do `createTodo`**

Para configurar assinaturas do GraphQL AWS AppSync, consulte [Criação](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-websocket-client.html) de um cliente em tempo real. WebSocket [Em uma instância do Amazon EC2 em uma VPC, você pode testar seu endpoint de assinatura de API AWS AppSync privada usando o wscat.](https://github.com/websockets/wscat) O exemplo abaixo usa um `API KEY` para autorização.

```
$ header=`echo '{"host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com","x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}"}' | base64 | tr -d '\n'`
$ wscat -p 13 -s graphql-ws -c  "wss://{api_url_identifier}.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=$header&payload=e30="
Connected (press CTRL+C to quit)
> {"type": "connection_init"}
< {"type":"connection_ack","payload":{"connectionTimeoutMs":300000}}
< {"type":"ka"}
> {"id":"f7a49717","payload":{"data":"{\"query\":\"subscription onCreateTodo {onCreateTodo {description id name where when}}\",\"variables\":{}}","extensions":{"authorization":{"x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}","host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com"}}},"type":"start"}
< {"id":"f7a49717","type":"start_ack"}
```

Como alternativa, use o nome de domínio do endpoint da VPC e, ao mesmo tempo, certifique-se de especificar o cabeçalho **Host** no comando `wscat` para estabelecer o websocket:

```
$ header=`echo '{"host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com","x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}"}' | base64 | tr -d '\n'`
$ wscat -p 13 -s graphql-ws -c  "wss://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql?header=$header&payload=e30=" --header Host:{api_url_identifier}.appsync-realtime-api.us-west-2.amazonaws.com
Connected (press CTRL+C to quit)
> {"type": "connection_init"}
< {"type":"connection_ack","payload":{"connectionTimeoutMs":300000}}
< {"type":"ka"}
> {"id":"f7a49717","payload":{"data":"{\"query\":\"subscription onCreateTodo {onCreateTodo {description id priority title}}\",\"variables\":{}}","extensions":{"authorization":{"x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}","host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com"}}},"type":"start"}
< {"id":"f7a49717","type":"start_ack"}
```

Execute o código de mutação abaixo:

```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```

Depois disso, uma assinatura é acionada, e a mensagem de notificação aparece conforme mostrado abaixo:

```
< {"id":"f7a49717","type":"data","payload":{"data":{"onCreateTodo":{"description":"Go to the shops","id":"169ce516-b7e8-4a6a-88c1-ab840184359f","priority":5,"title":"Go to the shops"}}}}
```

## Exemplos do ambiente de gerenciamento
<a name="control-plane-examples"></a>

Com o endpoint VPC do plano de controle configurado, você pode gerenciar AWS AppSync recursos de dentro da sua VPC usando o ou. AWS CLI SDKs Aqui estão exemplos de operações do ambiente de gerenciamento comuns:

**Criação de uma API usando o AWS CLI**

```
aws appsync create-graphql-api \
  --name "MyPrivateAPI" \
  --authentication-type API_KEY \
  --visibility PRIVATE
```

**Atualizando um esquema**

```
aws appsync start-schema-creation \
  --api-id {api-id} \
  --definition file://schema.graphql
```

**Criação de fonte de dados**

```
aws appsync create-data-source \
  --api-id {api-id} \
  --name "MyDataSource" \
  --type AWS_LAMBDA \
  --lambda-config lambdaFunctionArn=arn:aws:lambda:{region}:{account}:function:MyFunction
```

Durante o uso do endpoint do ambiente de gerenciamento com o DNS privado habilitado, esses comandos serão encaminhados automaticamente pelo endpoint da VPC. Se o DNS privado não estiver habilitado, você poderá especificar o URL do endpoint:

```
aws appsync create-graphql-api \
  --endpoint-url https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync.{region}.vpce.amazonaws.com \
  --name "MyPrivateAPI" \
  --authentication-type API_KEY \
  --visibility PRIVATE
```

## Usar políticas do IAM para limitar a criação de API pública
<a name="blocking-public-apis"></a>

AWS AppSync oferece suporte a [`Condition`declarações](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) do IAM para uso com Private APIs. O `visibility` campo pode ser incluído nas declarações de política do IAM para que a `appsync:CreateGraphqlApi` operação controle quais funções e usuários do IAM podem criar privados e públicos APIs. Com isso, o administrador do IAM pode definir uma política do IAM que só permitirá que um usuário crie uma API privada do GraphQL. Um usuário que tentar criar uma API pública receberá uma mensagem informando que a operação não é autorizada. 

Por exemplo, um administrador do IAM poderia criar a seguinte declaração de política do IAM para permitir a criação de Private APIs:

```
{
    "Sid": "AllowPrivateAppSyncApis",
    "Effect": "Allow",
    "Action": "appsync:CreateGraphqlApi",
    "Resource": "*",
    "Condition": {
        "ForAnyValue:StringEquals": {
            "appsync:Visibility": "PRIVATE"
        }
    }
}
```

Um administrador do IAM também pode adicionar a seguinte [política de controle de serviços](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) para impedir que todos os usuários de uma AWS organização criem algo AWS AppSync APIs diferente de Privado APIs:

```
{
    "Sid": "BlockNonPrivateAppSyncApis",
    "Effect": "Deny",
    "Action": "appsync:CreateGraphqlApi",
    "Resource": "*",
    "Condition": {
        "ForAnyValue:StringNotEquals": {
            "appsync:Visibility": "PRIVATE"
        }
    }
}
```

## Suporte para VPC PrivateLink
<a name="privatelink-support"></a>

O suporte ao VPC Privatelink está disponível em. AWS AppSync PrivateLink permite que você use e interaja com um AWS Serviço sem que nenhum tráfego saia da AWS rede. 

AWS AppSync suporta operações AWS PrivateLink de plano de dados e plano de controle.
+ **Endpoint VPCE** (`appsync.<region>.vpce.amazonaws.com`): dá acesso de VPC a operações do plano de dados e do ambiente de gerenciamento assim:
  + **appsync** para operações do ambiente de gerenciamento
  + **appsync-api** para operações de plano de dados