Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Accès à l'identifiant du locataire dans le code de fonction Lambda
<a name="tenant-isolation-context"></a>

Lorsque l'isolation des locataires est activée dans votre fonction Lambda, l'identifiant de locataire utilisé pour appeler votre fonction est mis à disposition dans l'objet de contexte transmis à votre gestionnaire de fonctions. Vous pouvez utiliser cet identifiant pour implémenter des fonctionnalités de logique, de surveillance et de débogage spécifiques au locataire.

**Topics**
+ [Accès à l'identifiant du locataire](#tenant-isolation-context-access)
+ [Modèles d'utilisation courants](#tenant-isolation-context-patterns)
+ [Surveillance et débogage](#tenant-isolation-context-monitoring)

## Accès à l'identifiant du locataire
<a name="tenant-isolation-context-access"></a>

L'identifiant du locataire est disponible via la `tenantId` propriété de l'objet de contexte. Notez que cette propriété est disponible pendant la phase d'[appel, et non pendant la phase](lambda-runtime-environment.md#runtimes-lifecycle-invoke) d'[initialisation](lambda-runtime-environment.md#runtimes-lifecycle-ib).

------
#### [ 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);
        }
    }
}
```

------

## Modèles d'utilisation courants
<a name="tenant-isolation-context-patterns"></a>

Voici les méthodes les plus courantes pour utiliser l'identifiant du locataire dans votre code de fonction :

**Configuration spécifique au locataire**

Utilisez l'ID du locataire pour charger la configuration ou les paramètres spécifiques au locataire :

```
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)
```

**Accès aux données spécifique au locataire**

Utilisez l'ID du locataire pour garantir l'isolation des données et le contrôle d'accès :

```
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)
```

## Surveillance et débogage
<a name="tenant-isolation-context-monitoring"></a>

L'identifiant du locataire est automatiquement inclus dans les journaux Lambda lorsque la [journalisation JSON est activée](monitoring-cloudwatchlogs-logformat.md), ce qui facilite le suivi et le débogage des problèmes spécifiques au locataire. Vous pouvez également utiliser l'ID du locataire pour des mesures et un suivi personnalisés.

**Example Métriques personnalisées avec identifiant de locataire**  
L'exemple suivant montre comment utiliser l'ID du locataire pour créer des CloudWatch métriques spécifiques au locataire afin de surveiller les modèles d'utilisation et les performances par locataire :  

```
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)
```