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.

# Zugreifen auf die Mandanten-ID im Lambda-Funktionscode
<a name="tenant-isolation-context"></a>

Wenn für Ihre Lambda-Funktion die Mandantenisolierung aktiviert ist, wird die Mandanten-ID, die zum Aufrufen Ihrer Funktion verwendet wurde, in dem Kontextobjekt verfügbar gemacht, das an Ihren Funktionshandler übergeben wird. Sie können diesen Bezeichner verwenden, um mandantenspezifische Logik-, Überwachungs- und Debugging-Funktionen zu implementieren.

**Topics**
+ [Zugreifen auf die Mandanten-ID](#tenant-isolation-context-access)
+ [Allgemeine Nutzungsmuster](#tenant-isolation-context-patterns)
+ [Überwachung und Debugging](#tenant-isolation-context-monitoring)

## Zugreifen auf die Mandanten-ID
<a name="tenant-isolation-context-access"></a>

Die Mandanten-ID ist über die `tenantId` Eigenschaft des Kontextobjekts verfügbar. Beachten Sie, dass diese Eigenschaft während der [Aufrufphase](lambda-runtime-environment.md#runtimes-lifecycle-invoke) und nicht während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) verfügbar ist.

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

```
def lambda_handler(event, context):
    tenant_id = context.tenant_id
    print(f"Processing request for tenant: {tenant_id}")
    
    # Implement tenant-specific logic
    if tenant_id == "blue":
        return process_blue_tenant(event)
    elif tenant_id == "green":
        return process_green_tenant(event)
    else:
        return process_default_tenant(event)
```

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

```
exports.handler = async (event, context) => {
    const tenantId = context.tenantId;
    console.log(`Processing request for tenant: ${tenantId}`);
    
    // Implement tenant-specific logic
    switch (tenantId) {
        case 'blue':
            return processBlueTenant(event);
        case 'green':
            return processGreenTenant(event);
        default:
            return processDefaultTenant(event);
    }
};
```

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

```
public class TenantHandler implements RequestHandler<Map<String, Object>, String> {
    
    @Override
    public String handleRequest(Map<String, Object> event, Context context) {
        String tenantId = context.getTenantId();
        System.out.println("Processing request for tenant: " + tenantId);
        
        // Implement tenant-specific logic
        switch (tenantId) {
            case "blue":
                return processBlueTenant(event);
            case "green":
                return processGreenTenant(event);
            default:
                return processDefaultTenant(event);
        }
    }
}
```

------

## Allgemeine Nutzungsmuster
<a name="tenant-isolation-context-patterns"></a>

Im Folgenden finden Sie gängige Methoden zur Verwendung der Mandanten-ID in Ihrem Funktionscode:

**Mandantenspezifische Konfiguration**

Verwenden Sie die Mandanten-ID, um die mandantenspezifische Konfiguration oder Einstellungen zu laden:

```
def lambda_handler(event, context):
    tenant_id = context.tenant_id
    
    # Load tenant-specific configuration
    config = load_tenant_config(tenant_id)
    database_url = config['database_url']
    api_key = config['api_key']
    
    # Process with tenant-specific settings
    return process_request(event, database_url, api_key)
```

**Mandantenspezifischer Datenzugriff**

Verwenden Sie die Mandanten-ID, um die Datenisolierung und Zugriffskontrolle sicherzustellen:

```
import boto3

def lambda_handler(event, context):
    tenant_id = context.tenant_id
    
    # Ensure data access is scoped to the tenant
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('user_data')
    
    user_id = event.get('userId')
    
    response = table.get_item(
        Key={
            'tenant_id': tenant_id,
            'user_id': user_id
        }
    )
    
    return process_results(response.get('Item'), tenant_id)
```

## Überwachung und Debugging
<a name="tenant-isolation-context-monitoring"></a>

Die Mandanten-ID wird automatisch in Lambda-Logs aufgenommen, wenn Sie die [JSON-Protokollierung aktiviert](monitoring-cloudwatchlogs-logformat.md) haben, sodass mandantenspezifische Probleme leichter überwacht und debuggt werden können. Sie können die Mandanten-ID auch für benutzerdefinierte Metriken und die Ablaufverfolgung verwenden.

**Example Benutzerdefinierte Metriken mit Mandanten-ID**  
Das folgende Beispiel zeigt, wie Sie die Mandanten-ID verwenden, um mandantenspezifische CloudWatch Metriken zur Überwachung von Nutzungsmustern und Leistung pro Mandant zu erstellen:  

```
import boto3

def lambda_handler(event, context):
    tenant_id = context.tenant_id
    cloudwatch = boto3.client('cloudwatch')
    
    # Record tenant-specific metrics
    cloudwatch.put_metric_data(
        Namespace='MyApp/TenantMetrics',
        MetricData=[
            {
                'MetricName': 'RequestCount',
                'Dimensions': [
                    {
                        'Name': 'TenantId',
                        'Value': tenant_id
                    }
                ],
                'Value': 1,
                'Unit': 'Count'
            }
        ]
    )
    
    return process_request(event, tenant_id)
```