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

# Introdução à API do Gerenciador de Sessões


A API do Gerenciador de Sessões do Amazon DCV fornece uma interface automatizada para gerenciar sessões de área de trabalho remota. Por meio dessa API, os desenvolvedores podem criar, listar, iniciar, parar e controlar sessões do DCV programaticamente. Isso permite a integração da funcionalidade do Amazon DCV em aplicativos e fluxos de trabalho personalizados. Ao aproveitar esta API, as organizações podem otimizar o gerenciamento de workloads de visualização remota, automatizando muitas tarefas comuns.

Antes de começar a fazer chamadas para a API do Amazon DCV, você precisará obter um token de acesso que autentique seu aplicativo e o autorize a acessar os recursos necessários. Como a API do Amazon DCV usa OAuth 2.0 para autenticação, você precisará registrar seu aplicativo e recuperar as credenciais necessárias. Depois de ter seu token de acesso, você pode começar a enviar solicitações aos endpoints da API do Amazon DCV para começar a processar dados.

**Topics**
+ [

# Etapa 1: gerar seu cliente de API
](client-sdk.md)
+ [

# Etapa 2: registrar a API de cliente
](credentials.md)
+ [

# Etapa 3: obter um token de acesso e faça uma solicitação de API
](request.md)

# Etapa 1: gerar seu cliente de API


As APIs do Gerenciador de Sessões são definidas em um único arquivo YAML. As APIs são baseadas na especificação OpenAPI3.0, que define uma interface padrão independente de linguagem para APIs RESTful. Para obter mais informações, consulte [Especificação de OpenAPI](https://swagger.io/specification/).

Usando o arquivo YAML, você pode gerar clientes de API em um dos idiomas compatíveis. Para fazer isso, você deve usar o Swagger Codegen versão 3.0 ou posterior. Para obter mais informações sobre os idiomas compatíveis, consulte o [repositório swagger-codegen](https://github.com/swagger-api/swagger-codegen#overview). 

**Para gerar o cliente da API**

1. Baixe o arquivo YAML da API do Gerenciador de Sessões no Agente do Gerenciador de Sessões. O arquivo YAML está disponível no seguinte URL.

   ```
   https://broker_host_ip:port/dcv-session-manager-api.yaml
   ```

1. Instale o Swagger Codegen.
   + macOS

     ```
     $ brew install swagger-codegen
     ```
   + Outras plataformas

     ```
     $ git clone https://github.com/swagger-api/swagger-codegen --branch 3.0.0
     ```

     ```
     $ cd swagger-codegen
     ```

1. Gere o cliente da API.
   + macOS

     ```
     $ swagger-codegen generate -i /path_to/yaml_file -l language -o $output_folder
     ```
   + Outras plataformas

     ```
     $ mvn clean package
     ```

     ```
     $ java -jar modules/swagger-codegen-cli/target/swagger-codegen-cli.jar generate -i /path_to/yaml_file -l language -o output_folder
     ```

# Etapa 2: registrar a API de cliente


As solicitações de API usam um token de acesso para verificar suas credenciais. Essas credenciais se baseiam em um ID de cliente e senha de cliente gerados quando seu cliente é registrado no Agente.

Para acessar esse token, você precisa se registrar com o agente. Use [register-api-client](https://docs.aws.amazon.com/dcv/latest/sm-admin/register-api-client.html) para registrar a API do cliente.

Se você não tiver um ID de cliente e uma senha de cliente para seu cliente, deverá solicitá-los ao administrador do Agente.

# Etapa 3: obter um token de acesso e faça uma solicitação de API


Este exemplo explicará as etapas para configurar seu token de acesso e, em seguida, mostrará como fazer uma solicitação básica de API. Isso fornecerá o conhecimento básico para começar a criar aplicativos mais avançados com a API do Amazon DCV.

Neste exemplo, mostraremos como fazer isso usando a API `DescribeSessions`.

**Example**  
Primeiro, importamos os modelos necessários para o aplicativo.  
Em seguida, declaramos variáveis para o ID do cliente (`__CLIENT_ID`), a senha do cliente (`__CLIENT_SECRET`) e o URL do Agente, incluindo o número da porta (`__PROTOCOL_HOST_PORT`).  
Em seguida, criamos uma função chamada `build_client_credentials` que gera as credenciais do cliente. Para gerar as credenciais do cliente, primeiro você deve concatenar o ID do cliente e a senha do cliente e separar os valores com dois pontos (`client_ID:client_password`) e, em seguida, codificar a string inteira em Base64.  

```
import swagger_client
import base64
import requests
import json
from swagger_client.models.describe_sessions_request_data import DescribeSessionsRequestData
from swagger_client.models.key_value_pair import KeyValuePair
from swagger_client.models.delete_session_request_data import DeleteSessionRequestData
from swagger_client.models.update_session_permissions_request_data import UpdateSessionPermissionsRequestData
from swagger_client.models.create_session_request_data import CreateSessionRequestData

__CLIENT_ID = '794b2dbb-bd82-4707-a2f7-f3d9899cb386'
__CLIENT_SECRET = 'MzcxNzJhN2UtYjEzNS00MjNjLTg2N2YtMjFlZmRlZWNjMDU1'
__PROTOCOL_HOST_PORT = 'https://<broker-hostname>:8443'

def build_client_credentials():
    client_credentials = '{client_id}:{client_secret}'.format(client_id=__CLIENT_ID, client_secret=__CLIENT_SECRET)
    return base64.b64encode(client_credentials.encode('utf-8')).decode('utf-8')
```
Agora que temos nossas credenciais de cliente, podemos usá-las para solicitar um token de acesso ao Agente. Para fazer isso, criamos uma função chamada `get_access_token`. Você deve chamar um `POST` em ` https://Broker_IP:8443/oauth2/token?grant_type=client_credentials` e fornecer um cabeçalho de autorização, que inclua as credenciais do cliente codificadas em Basic e um tipo de conteúdo de `application/x-www-form-urlencoded`.  

```
def get_access_token():
    client_credentials = build_client_credentials()
    headers = {
        'Authorization': 'Basic {}'.format(client_credentials),
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    endpoint = __PROTOCOL_HOST_PORT + '/oauth2/token?grant_type=client_credentials'
    print('Calling', endpoint, 'using headers', headers)
    res = requests.post(endpoint, headers=headers, verify=True)
    if res.status_code != 200:
        print('Cannot get access token:', res.text)
        return None
    access_token = json.loads(res.text)['access_token']
    print('Access token is', access_token)
    return access_token
```
Agora, criamos as funções necessárias para instanciar uma API de cliente. Para instanciar uma API de cliente, você deve especificar a configuração do cliente e os cabeçalhos a serem usados nas solicitações. A função `get_client_configuration` cria um objeto de configuração que inclui o endereço IP e a porta do Agente e o caminho para o certificado autoassinado do Agente, que você deve ter recebido do administrador do Agente. A função `set_request_headers` cria um objeto de cabeçalho de solicitação que inclui as credenciais do cliente e o token de acesso.  

```
def get_client_configuration():
    configuration = swagger_client.Configuration()
    configuration.host = __PROTOCOL_HOST_PORT
    configuration.verify_ssl = True
    # configuration.ssl_ca_cert = cert_file.pem
    return configuration

def set_request_headers(api_client):
    access_token = get_access_token()
    api_client.set_default_header(header_name='Authorization',
                                  header_value='Bearer {}'.format(access_token))

def get_sessions_api():
    api_instance = swagger_client.SessionsApi(swagger_client.ApiClient(get_client_configuration()))
    set_request_headers(api_instance.api_client)
    return api_instance
```
Por fim, criamos um método principal que chama a API `DescribeSessions`. Para obter mais informações, consulte [DescribeSessions](DescribeSessions.md).  

```
def describe_sessions(session_ids=None, next_token=None, tags=None, owner=None):
    filters = list()
    if tags:
        for tag in tags:
            filter_key_value_pair = KeyValuePair(key='tag:' + tag['Key'], value=tag['Value'])
            filters.append(filter_key_value_pair)
    if owner:
        filter_key_value_pair = KeyValuePair(key='owner', value=owner)
        filters.append(filter_key_value_pair)

    request = DescribeSessionsRequestData(session_ids=session_ids, filters=filters, next_token=next_token)
    print('Describe Sessions Request:', request)
    api_instance = get_sessions_api()
    api_response = api_instance.describe_sessions(body=request)
    print('Describe Sessions Response', api_response)
    
def main():
    describe_sessions(
        session_ids=['SessionId1895', 'SessionId1897'],
        owner='an owner 1890',
        tags=[{'Key': 'ram', 'Value': '4gb'}])
```