Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo dei parametri nei modelli di PySpark analisi
<a name="pyspark-parameter-handling"></a>

I parametri aumentano la flessibilità dei modelli di PySpark analisi consentendo di fornire valori diversi al momento dell'invio del lavoro. I parametri sono accessibili tramite l'oggetto contestuale passato alla funzione entrypoint.

**Nota**  
I parametri sono stringhe fornite dall'utente che possono contenere contenuti arbitrari.  
Esamina il codice per assicurarti che i parametri vengano gestiti in modo sicuro per evitare comportamenti imprevisti durante l'analisi.
Progettate la gestione dei parametri in modo che funzioni in sicurezza indipendentemente dai valori dei parametri forniti al momento dell'invio.

## Accesso ai parametri
<a name="accessing-parameters"></a>

I parametri sono disponibili nel `context['analysisParameters']` dizionario. Tutti i valori dei parametri sono stringhe.

**Example Accesso sicuro ai parametri**  

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

## Best practice sulla sicurezza dei parametri
<a name="parameter-security-best-practices"></a>

**avvertimento**  
I parametri sono stringhe fornite dall'utente che possono contenere contenuti arbitrari. È necessario gestire i parametri in modo sicuro per prevenire vulnerabilità di sicurezza nel codice di analisi.

**Schemi di gestione dei parametri non sicuri per evitare:**
+ **Esecuzione dei parametri come codice**: non utilizzare mai `eval()` o `exec()` sui valori dei parametri

  ```
  # UNSAFE - Don't do this
  eval(parameters['expression'])  # Can execute arbitrary code
  ```
+ **Interpolazione di stringhe SQL**: non concatenate mai i parametri direttamente nelle stringhe SQL

  ```
  # UNSAFE - Don't do this
  sql = f"SELECT * FROM table WHERE column = '{parameters['value']}'"  # SQL injection risk
  ```
+ Operazioni **non sicure sui percorsi dei file: non utilizzare mai i parametri direttamente nelle operazioni** del file system senza convalida

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

**Modelli sicuri di gestione dei parametri:**
+ **Usa i parametri nelle DataFrame operazioni**: Spark DataFrames gestisce i valori dei parametri in modo sicuro

  ```
  # SAFE - Use parameters in DataFrame operations
  threshold = int(parameters['threshold'])
  filtered_df = input_df.filter(input_df.value > threshold)
  ```
+ **Convalida i valori dei parametri**: verifica che i parametri soddisfino i formati previsti prima dell'uso

  ```
  # 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}")
  ```
+ **Usa le liste di autorizzazione per i valori dei parametri**: quando possibile, convalida i parametri in base a valori corretti noti

  ```
  # 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}")
  ```
+ **Conversione dei tipi con gestione degli errori**: converte i parametri delle stringhe nei tipi previsti in modo sicuro

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

**Importante**  
Ricordate che i parametri ignorano la revisione del codice quando i job runner forniscono valori diversi. Progettate la gestione dei parametri in modo che funzioni in modo sicuro indipendentemente dai valori dei parametri forniti.

## Esempio completo di parametri
<a name="parameter-examples"></a>

**Example Utilizzo sicuro dei parametri in uno 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
```