Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit der Session Manager API
Die Amazon DCV Session Manager-API bietet eine automatisierte Schnittstelle für die Verwaltung von Remote-Desktop-Sitzungen. Über diese API können Entwickler DCV-Sitzungen programmgesteuert erstellen, auflisten, starten, beenden und anderweitig steuern. Dies ermöglicht die Integration der Amazon DCV-Funktionalität in benutzerdefinierte Anwendungen und Workflows. Durch die Nutzung dieser API können Unternehmen die Verwaltung von Remote-Visualisierungs-Workloads optimieren und viele allgemeine Aufgaben automatisieren.
Bevor Sie mit Aufrufen der Amazon DCV-API beginnen können, benötigen Sie ein Zugriffstoken, das Ihre Anwendung authentifiziert und sie für den Zugriff auf die erforderlichen Ressourcen autorisiert. Die Amazon DCV-API verwendet OAuth 2.0 für die Authentifizierung, sodass Sie Ihre Anwendung registrieren und die erforderlichen Anmeldeinformationen abrufen müssen. Sobald Sie Ihr Zugriffstoken haben, können Sie damit beginnen, Anfragen an die Amazon DCV-API-Endpunkte zu senden, um mit der Datenverarbeitung zu beginnen.
**Topics**
+ [Schritt 1: Generieren Sie Ihren API-Client](client-sdk.md)
+ [Schritt 2: Registrieren Sie Ihre Client-API](credentials.md)
+ [Schritt 3: Besorgen Sie sich ein Zugriffstoken und stellen Sie eine API-Anfrage](request.md)
# Schritt 1: Generieren Sie Ihren API-Client
Die Session Manager APIs sind in einer einzigen YAML-Datei definiert. Sie APIs basieren auf der Open API3 4.0-Spezifikation, die eine standardmäßige, sprachunabhängige Schnittstelle zu definiert. RESTful APIs Weitere Informationen finden Sie unter [OpenAPI-Spezifikation](https://swagger.io/specification/).
Mithilfe der YAML-Datei können Sie einen API-Client in einer der unterstützten Sprachen generieren. Dazu müssen Sie Swagger Codegen 3.0 oder höher verwenden. [Weitere Informationen zu den unterstützten Sprachen finden Sie im Swagger-Codegen-Repo.](https://github.com/swagger-api/swagger-codegen#overview)
**Um den API-Client zu generieren**
1. Laden Sie die Session Manager-API-YAML-Datei vom Session Manager Broker herunter. Die YAML-Datei ist unter der folgenden URL verfügbar.
```
https://broker_host_ip:port/dcv-session-manager-api.yaml
```
1. Installieren Sie Swagger Codegen.
+ macOS
```
$ brew install swagger-codegen
```
+ Andere Plattformen
```
$ git clone https://github.com/swagger-api/swagger-codegen --branch 3.0.0
```
```
$ cd swagger-codegen
```
1. Generieren Sie den API-Client.
+ macOS
```
$ swagger-codegen generate -i /path_to/yaml_file -l language -o $output_folder
```
+ Andere Plattformen
```
$ 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
```
# Schritt 2: Registrieren Sie Ihre Client-API
API-Anfragen verwenden ein Zugriffstoken, um Ihre Anmeldeinformationen zu überprüfen. Diese Anmeldeinformationen basieren auf einer Client-ID und einem Kundenpasswort, die generiert werden, wenn Ihr Kunde beim Broker registriert wird.
Um auf dieses Token zugreifen zu können, müssen Sie sich beim Broker registrieren. Wird [register-api-client](https://docs.aws.amazon.com/dcv/latest/sm-admin/register-api-client.html)zur Registrierung der Client-API verwendet.
Wenn Sie keine Client-ID und kein Kundenkennwort für Ihren Kunden haben, müssen Sie diese von Ihrem Broker-Administrator anfordern.
# Schritt 3: Besorgen Sie sich ein Zugriffstoken und stellen Sie eine API-Anfrage
In diesem Beispiel werden die Schritte zur Einrichtung Ihres Zugriffstokens beschrieben und anschließend gezeigt, wie Sie eine grundlegende API-Anfrage stellen. Auf diese Weise erhalten Sie das grundlegende Wissen, um mit der Entwicklung fortschrittlicherer Anwendungen zu beginnen, die auf der Amazon DCV-API basieren.
In diesem Beispiel zeigen wir Ihnen, wie Sie dies mithilfe der `DescribeSessions` API tun können.
**Example**
Zuerst importieren wir die für die Anwendung benötigten Modelle.
Dann deklarieren wir Variablen für die Client-ID (`__CLIENT_ID`), das Client-Passwort (`__CLIENT_SECRET`) und die Broker-URL, einschließlich der Portnummer (`__PROTOCOL_HOST_PORT`).
Als Nächstes erstellen wir eine Funktion namens`build_client_credentials`, die die Client-Anmeldeinformationen generiert. Um die Client-Anmeldeinformationen zu generieren, müssen Sie zuerst die Client-ID und das Client-Passwort verketten und die Werte durch einen Doppelpunkt (`client_ID:client_password`) trennen. Anschließend müssen Sie die gesamte Zeichenfolge mit Base64 kodieren.
```
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')
```
Da wir nun unsere Client-Anmeldeinformationen haben, können wir sie verwenden, um ein Zugriffstoken vom Broker anzufordern. Dazu erstellen wir eine Funktion namens`get_access_token`. Sie müssen ein `POST` on ` https://Broker_IP:8443/oauth2/token?grant_type=client_credentials` aufrufen und einen Autorisierungsheader angeben, der die BASIC-kodierten Client-Anmeldeinformationen und den Inhaltstyp enthält. `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
```
Jetzt erstellen wir die Funktionen, die für die Instanziierung einer Client-API erforderlich sind. Um eine Client-API zu instanziieren, müssen Sie die Client-Konfiguration und die Header angeben, die für Anfragen verwendet werden sollen. Die `get_client_configuration` Funktion erstellt ein Konfigurationsobjekt, das die IP-Adresse und den Port des Brokers sowie den Pfad zum selbstsignierten Zertifikat des Brokers enthält, das Sie vom Broker-Administrator erhalten haben sollten. Die `set_request_headers` Funktion erstellt ein Anforderungsheader-Objekt, das die Client-Anmeldeinformationen und das Zugriffstoken enthält.
```
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
```
Schließlich erstellen wir eine Hauptmethode, die die `DescribeSessions` API aufruft. Weitere Informationen finden Sie unter [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'}])
```