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.

# Utilisation des paramètres dans les modèles PySpark d'analyse
<a name="pyspark-parameter-handling"></a>

Les paramètres augmentent la flexibilité de vos modèles d' PySpark analyse en permettant de fournir différentes valeurs au moment de la soumission des tâches. Les paramètres sont accessibles via l'objet de contexte transmis à votre fonction de point d'entrée.

**Note**  
Les paramètres sont des chaînes fournies par l'utilisateur qui peuvent contenir du contenu arbitraire.  
Passez en revue le code pour vous assurer que les paramètres sont gérés en toute sécurité afin d'éviter tout comportement inattendu dans votre analyse.
Concevez la gestion des paramètres de manière à ce qu'elle fonctionne en toute sécurité, quelles que soient les valeurs des paramètres fournies au moment de la soumission.

## Accès aux paramètres
<a name="accessing-parameters"></a>

Les paramètres sont disponibles dans le `context['analysisParameters']` dictionnaire. Toutes les valeurs des paramètres sont des chaînes de caractères.

**Example Accès aux paramètres en toute sécurité**  

```
def entrypoint(context):
    # Access parameters from context
    parameters = context['analysisParameters']
    threshold = parameters['threshold']
    table_name = parameters['table_name']
    
    # Continue with analysis using parameters
    spark = context['sparkSession']
    input_df = context['referencedTables'][table_name]
    
    # Convert threshold value
    threshold_val = int(threshold)
    
    # Use parameter in DataFrame operation
    filtered_df = input_df.filter(input_df.amount > threshold_val)
    
    return {
        "results": {
            "output": filtered_df
        }
    }
```

## Bonnes pratiques de sécurité pour les paramètres
<a name="parameter-security-best-practices"></a>

**Avertissement**  
Les paramètres sont des chaînes fournies par l'utilisateur qui peuvent contenir du contenu arbitraire. Vous devez gérer les paramètres en toute sécurité pour éviter les failles de sécurité dans votre code d'analyse.

**Modèles de gestion des paramètres non sécurisés à éviter :**
+ **Exécution de paramètres sous forme de code** — Ne jamais utiliser `eval()` ou `exec()` sur des valeurs de paramètres

  ```
  # UNSAFE - Don't do this
  eval(parameters['expression'])  # Can execute arbitrary code
  ```
+ **Interpolation de chaînes SQL** — Ne concaténez jamais de paramètres directement dans des chaînes SQL

  ```
  # UNSAFE - Don't do this
  sql = f"SELECT * FROM table WHERE column = '{parameters['value']}'"  # SQL injection risk
  ```
+ **Opérations de chemin de fichier non sécurisées** : n'utilisez jamais de paramètres directement dans les opérations du système de fichiers sans validation

  ```
  # UNSAFE - Don't do this
  file_path = f"/data/{parameters['filename']}"  # Path traversal risk
  ```

**Modèles de gestion des paramètres sécurisés :**
+ **Utiliser les paramètres dans les DataFrame opérations** — Spark DataFrames gère les valeurs des paramètres en toute sécurité

  ```
  # SAFE - Use parameters in DataFrame operations
  threshold = int(parameters['threshold'])
  filtered_df = input_df.filter(input_df.value > threshold)
  ```
+ **Valider les valeurs des paramètres** — Vérifiez que les paramètres répondent aux formats attendus avant utilisation

  ```
  # SAFE - Validate parameters before use
  def validate_date(date_str):
      try:
          from datetime import datetime
          datetime.strptime(date_str, '%Y-%m-%d')
          return True
      except ValueError:
          return False
  
  date_param = parameters['date_filter'] or '2024-01-01'
  if not validate_date(date_param):
      raise ValueError(f"Invalid date format: {date_param}")
  ```
+ **Utiliser des listes d'autorisation pour les valeurs des paramètres** : dans la mesure du possible, validez les paramètres par rapport aux bonnes valeurs connues

  ```
  # SAFE - Use allowlists
  allowed_columns = ['column1', 'column2', 'column3']
  column_param = parameters['column_name']
  if column_param not in allowed_columns:
      raise ValueError(f"Invalid column: {column_param}")
  ```
+ **Conversion de type avec gestion des erreurs** — Convertissez les paramètres de chaîne en types attendus en toute sécurité

  ```
  # SAFE - Convert with error handling
  try:
      batch_size = int(parameters['batch_size'] or '1000')
      if batch_size <= 0 or batch_size > 10000:
          raise ValueError(f"Batch size must be between 1 and 10000")
  except ValueError as e:
      print(f"Invalid parameter: {e}")
      raise
  ```

**Important**  
N'oubliez pas que les paramètres ignorent la révision du code lorsque les exécuteurs de tâches fournissent des valeurs différentes. Concevez votre gestion des paramètres pour qu'elle fonctionne en toute sécurité, quelles que soient les valeurs de paramètres fournies.

## Exemple de paramètre complet
<a name="parameter-examples"></a>

**Example Utilisation sécurisée des paramètres dans un PySpark script**  

```
def entrypoint(context):
    try:
        # Access Spark session and tables
        spark = context['sparkSession']
        input_table = context['referencedTables']['sales_data']
        
        # Access parameters - fail fast if analysisParameters missing
        parameters = context['analysisParameters']
        
        # Validate and convert numeric parameter (handles empty strings with default)
        try:
            threshold = int(parameters['threshold'] or '100')
            if threshold <= 0:
                raise ValueError("Threshold must be positive")
        except (ValueError, TypeError) as e:
            print(f"Invalid threshold parameter: {e}")
            raise
        
        # Validate date parameter (handles empty strings with default)
        date_filter = parameters['start_date'] or '2024-01-01'
        from datetime import datetime
        try:
            datetime.strptime(date_filter, '%Y-%m-%d')
        except ValueError:
            raise ValueError(f"Invalid date format: {date_filter}")
        
        # Use parameters safely in DataFrame operations
        filtered_df = input_table.filter(
            (input_table.amount > threshold) &
            (input_table.date >= date_filter)
        )
        
        result_df = filtered_df.groupBy("category").agg(
            {"amount": "sum"}
        )
        
        return {
            "results": {
                "filtered_results": result_df
            }
        }
    
    except Exception as e:
        print(f"Error in analysis: {str(e)}")
        raise
```