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.

# Aufrufen von Lambda-Funktionen mit Mandantenisolierung
<a name="tenant-isolation-invoke"></a>

Wenn Sie eine Funktion aufrufen, für die die Mandantenisolierung aktiviert ist, müssen Sie einen Parameter angeben. `tenant-id` Dieser Parameter stellt sicher, dass Ihr Funktionsaufruf in einer Ausführungsumgebung verarbeitet wird, die diesem bestimmten Mandanten zugewiesen ist.

## Aufrufen von Funktionen mit Tenant Isolation ()AWS CLI
<a name="tenant-isolation-invoke-cli"></a>

**Synchroner Aufruf**

[Fügen Sie für synchrone Aufrufe den `--tenant-id` Parameter zu Ihrem Invoke-Befehl hinzu:](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)

```
aws lambda invoke \
    --function-name {{image-analysis}} \
    --tenant-id {{blue}} \
    response.json
```

**Asynchroner Aufruf**

Geben Sie bei asynchronen Aufrufen sowohl die als auch die Parameter an: `--tenant-id` `--invocation-type Event`

```
aws lambda invoke \
    --function-name {{image-analysis}} \
    --tenant-id {{blue}} \
    --invocation-type Event \
    response.json
```

## Funktionen mit Mandantenisolierung (API) aufrufen
<a name="tenant-isolation-invoke-api"></a>

Wenn Sie die Aktion „API [aufrufen](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)“ direkt verwenden, geben Sie die Mandanten-ID mithilfe des `X-Amzn-Tenant-Id` Parameters in Ihre Anfrage ein.

**Beispiel für eine API-Anfrage**

```
POST /2015-03-31/functions/{{image-analysis}}/invocations HTTP/1.1
Host: lambda.{{us-east-1}}.amazonaws.com
Content-Type: application/json
Authorization: AWS4-HMAC-SHA256 Credential=...
X-Amz-Tenant-Id: {{blue}}

{
    "key1": "value1",
    "key2": "value2"
}
```

## Aufrufen von Funktionen mit Mandantenisolierung (API Gateway)
<a name="tenant-isolation-invoke-apigateway"></a>

Wenn Sie API Gateway REST verwenden APIs , um mandantenisolierte Lambda-Funktionen auszulösen, müssen Sie API Gateway so konfigurieren, dass die Eigenschaften der Client-Anfrage dem von Lambda erwarteten `X-Amz-Tenant-Id` Header zugeordnet werden. API Gateway verwendet die Aktion „API [aufrufen](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)“ von Lambda, bei der die Mandanten-ID über den `X-Amz-Tenant-Id` HTTP-Header übergeben werden muss. Sie können API Gateway so konfigurieren, dass dieser HTTP-Header mit einem Wert, der aus Eigenschaften der Client-Anfrage wie HTTP-Headern, Abfrageparametern oder Pfadparametern abgerufen wird, in die Lambda-Aufrufanforderung eingefügt wird. Sie müssen zuerst die Eigenschaft der Client-Anfrage zuordnen, bevor Sie den Header überschreiben können. `X-Amz-Tenant-Id`

**Anmerkung**  
Sie können HTTP nicht verwenden APIs , um mandantenisolierte Lambda-Funktionen aufzurufen, da es nicht möglich ist, den Header zu überschreiben. `X-Amz-Tenant-Id`

**Verwenden von Anforderungsheadern**

Konfigurieren Sie Ihre API-Gateway-Integration so, dass ein benutzerdefinierter Header von der Client-Anfrage dem `X-Amz-Tenant-Id` Header zugeordnet wird. Das folgende Beispiel zeigt eine Client-Anfrage mit einem `x-tenant-id` Header:

```
POST /api/process HTTP/1.1
Host: {{your-api-id}}.execute-api.{{us-east-1}}.amazonaws.com
Content-Type: application/json
x-tenant-id: {{blue}}

{
    "data": "sample payload"
}
```

In Ihrer API Gateway Gateway-Methodenkonfiguration müssen Sie:

1. Aktivieren Sie den Header-Parameter für die Client-Anfrage (zum Beispiel`method.request.header.x-tenant-id`)

1. Ordnen Sie den Client-Header dem Lambda-Integrationsheader zu, indem Sie `integration.request.header.X-Amz-Tenant-Id`

**Verwenden von Abfrageparametern**

Auf ähnliche Weise können Sie dem `X-Amz-Tenant-Id` Header Abfrageparameter zuordnen:

```
GET /api/process?tenant-id={{blue}}&data={{sample}} HTTP/1.1
Host: {{your-api-id}}.execute-api.{{us-east-1}}.amazonaws.com
```

Konfigurieren Sie die Methode so, dass der Abfrageparameter aktiviert wird, und ordnen Sie ihn dem Integrationsheader zu.

## Funktionen mit Tenant Isolation (SDK) aufrufen
<a name="tenant-isolation-invoke-sdk"></a>

Wenn Sie Funktionen verwenden AWS SDKs , die vom Mandanten isoliert sind, geben Sie die Mandanten-ID in Ihre Aufrufanforderung ein.

------
#### [ Python ]

```
import boto3
import json

lambda_client = boto3.client('lambda')

response = lambda_client.invoke(
    FunctionName='{{image-analysis}}',
    TenantId='{{blue}}',
    Payload=json.dumps({
        'key1': 'value1',
        'key2': 'value2'
    })
)

result = json.loads(response['Payload'].read())
```

------
#### [ Node.js ]

```
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda();

const params = {
    FunctionName: '{{image-analysis}}',
    TenantId: '{{blue}}',
    Payload: JSON.stringify({
        key1: 'value1',
        key2: 'value2'
    })
};

lambda.invoke(params, (err, data) => {
    if (err) {
        console.error(err);
    } else {
        const result = JSON.parse(data.Payload);
        console.log(result);
    }
});
```

------
#### [ Java ]

```
import software.amazon.awssdk.services.lambda.LambdaClient;
import software.amazon.awssdk.services.lambda.model.InvokeRequest;
import software.amazon.awssdk.services.lambda.model.InvokeResponse;
import software.amazon.awssdk.core.SdkBytes;

public class TenantIsolationExample {

    public static void main(String[] args) {
        LambdaClient lambdaClient = LambdaClient.create();

        String payload = "{\"key1\": \"value1\", \"key2\": \"value2\"}";

        InvokeRequest request = InvokeRequest.builder()
                .functionName("{{image-analysis}}")
                .tenantId("{{blue}}")
                .payload(SdkBytes.fromUtf8String(payload))
                .build();

        InvokeResponse response = lambdaClient.invoke(request);
    }
}
```

------