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.

# Schritt 3: Besorgen Sie sich ein Zugriffstoken und stellen Sie eine API-Anfrage
<a name="request"></a>

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://<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')
```
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'}])
```