Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Guida introduttiva all'API Session Manager
L'API Amazon DCV Session Manager fornisce un'interfaccia automatizzata per la gestione delle sessioni di desktop remoto. Tramite questa API, gli sviluppatori possono creare, elencare, avviare, interrompere e controllare in altro modo le sessioni DCV a livello di codice. Ciò consente l'integrazione della funzionalità di Amazon DCV in applicazioni e flussi di lavoro personalizzati. Sfruttando questa API, le organizzazioni possono semplificare la gestione dei carichi di lavoro di visualizzazione remota, automatizzando molte attività comuni.
Prima di iniziare a effettuare chiamate all'API Amazon DCV, devi ottenere un token di accesso che autentichi l'applicazione e la autorizzi ad accedere alle risorse necessarie. L'API Amazon DCV utilizza la OAuth versione 2.0 per l'autenticazione, quindi dovrai registrare l'applicazione e recuperare le credenziali necessarie. Una volta ottenuto il token di accesso, puoi iniziare a inviare richieste agli endpoint dell'API Amazon DCV per iniziare l'elaborazione dei dati.
**Topics**
+ [Fase 1: Genera il tuo client API](client-sdk.md)
+ [Fase 2: Registra l'API del tuo client](credentials.md)
+ [Passaggio 3: Ottieni un token di accesso ed effettua una richiesta API](request.md)
# Fase 1: Genera il tuo client API
I Session Manager APIs sono definiti in un unico file YAML. APIs Si basano sulla specifica Open API3 .0, che definisce un'interfaccia standard indipendente dalla lingua per. RESTful APIs Per ulteriori informazioni, consulta la [specifica OpenAPI](https://swagger.io/specification/).
Utilizzando il file YAML, è possibile generare un client API in una delle lingue supportate. Per fare ciò, è necessario utilizzare Swagger Codegen 3.0 o versione successiva. [Per ulteriori informazioni sulle lingue supportate, consulta il repository swagger-codegen.](https://github.com/swagger-api/swagger-codegen#overview)
**Per generare il client API**
1. Scarica il file YAML dell'API Session Manager dal Session Manager Broker. Il file YAML è disponibile al seguente URL.
```
https://broker_host_ip:port/dcv-session-manager-api.yaml
```
1. Installa Swagger Codegen.
+ macOS
```
$ brew install swagger-codegen
```
+ Altre piattaforme
```
$ git clone https://github.com/swagger-api/swagger-codegen --branch 3.0.0
```
```
$ cd swagger-codegen
```
1. Genera il client API.
+ macOS
```
$ swagger-codegen generate -i /path_to/yaml_file -l language -o $output_folder
```
+ Altre piattaforme
```
$ 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
```
# Fase 2: Registra l'API del tuo client
Le richieste API utilizzano un token di accesso per verificare le credenziali. Queste credenziali si basano su un ID cliente e una password client generati quando il cliente è registrato presso il Broker.
Per accedere a questo token, è necessario registrarsi presso il Broker. Utilizzalo [register-api-client](https://docs.aws.amazon.com/dcv/latest/sm-admin/register-api-client.html)per registrare l'API del client.
Se non disponi di un ID cliente e di una password client per il tuo cliente, devi richiederli all'amministratore del tuo Broker.
# Passaggio 3: Ottieni un token di accesso ed effettua una richiesta API
Questo esempio illustrerà i passaggi per configurare il token di accesso, quindi ti mostrerà come effettuare una richiesta API di base. Questo ti fornirà le conoscenze di base per iniziare a creare applicazioni più avanzate basate sull'API Amazon DCV.
In questo esempio, ti mostreremo come farlo utilizzando l'`DescribeSessions`API.
**Example**
Per prima cosa importiamo i modelli necessari per l'applicazione.
Quindi dichiariamo le variabili per l'ID client (`__CLIENT_ID`), la password del client (`__CLIENT_SECRET`) e l'URL del broker, incluso il numero di porta (`__PROTOCOL_HOST_PORT`).
Successivamente, creiamo una funzione chiamata `build_client_credentials` che genera le credenziali del client. Per generare le credenziali del client, è necessario prima concatenare l'ID client e la password del client e separare i valori con i due punti (`client_ID:client_password`), quindi Base64 codificare l'intera stringa.
```
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://: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')
```
Ora che abbiamo le credenziali del nostro cliente, possiamo usarle per richiedere un token di accesso al Broker. Per fare ciò, creiamo una funzione chiamata`get_access_token`. È necessario chiamare un `POST` on ` https://Broker_IP:8443/oauth2/token?grant_type=client_credentials` e fornire un'intestazione di autorizzazione, che includa le credenziali client con codifica Basic e un tipo di contenuto di. `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
```
Ora creiamo le funzioni necessarie per creare un'istanza di un'API client. Per creare un'istanza di un'API client, è necessario specificare la configurazione del client e le intestazioni da utilizzare per le richieste. La `get_client_configuration` funzione crea un oggetto di configurazione che include l'indirizzo IP e la porta del Broker e il percorso del certificato autofirmato del Broker, che avresti dovuto ricevere dall'amministratore del Broker. La `set_request_headers` funzione crea un oggetto di intestazione della richiesta che include le credenziali del client e il token di accesso.
```
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
```
Infine, creiamo un metodo principale che chiama l'`DescribeSessions`API. Per ulteriori informazioni, consulta [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'}])
```