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.

# Arbeiten mit Parametern in PySpark Analysevorlagen
<a name="pyspark-parameter-handling"></a>

Parameter erhöhen die Flexibilität Ihrer PySpark Analysevorlagen, da bei der Einreichung des Jobs unterschiedliche Werte angegeben werden können. Auf Parameter kann über das Kontextobjekt zugegriffen werden, das an Ihre Einstiegsfunktion übergeben wurde.

**Anmerkung**  
Parameter sind vom Benutzer bereitgestellte Zeichenketten, die beliebigen Inhalt enthalten können.  
Überprüfen Sie den Code, um sicherzustellen, dass die Parameter sicher behandelt werden, um unerwartetes Verhalten in Ihrer Analyse zu verhindern.
Entwerfen Sie die Parameterbehandlung so, dass sie sicher funktioniert, unabhängig davon, welche Parameterwerte zum Zeitpunkt der Einreichung angegeben werden.

## Zugreifen auf Parameter
<a name="accessing-parameters"></a>

Parameter sind im `context['analysisParameters']` Wörterbuch verfügbar. Alle Parameterwerte sind Zeichenketten.

**Example Sicherer Zugriff auf Parameter**  

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

## Bewährte Methoden für die Parametersicherheit
<a name="parameter-security-best-practices"></a>

**Warnung**  
Parameter sind vom Benutzer bereitgestellte Zeichenketten, die beliebigen Inhalt enthalten können. Sie müssen mit Parametern sicher umgehen, um Sicherheitslücken in Ihrem Analysecode zu vermeiden.

**Unsichere Muster bei der Parameterbehandlung sollten Sie Folgendes vermeiden:**
+ **Parameter als Code ausführen** — Verwenden Sie niemals `eval()` oder für `exec()` Parameterwerte

  ```
  # UNSAFE - Don't do this
  eval(parameters['expression'])  # Can execute arbitrary code
  ```
+ **Interpolation von SQL-Zeichenketten** — Verketten Sie niemals Parameter direkt zu SQL-Zeichenfolgen

  ```
  # UNSAFE - Don't do this
  sql = f"SELECT * FROM table WHERE column = '{parameters['value']}'"  # SQL injection risk
  ```
+ **Unsichere Dateipfadoperationen** — Verwenden Sie Parameter niemals direkt in Dateisystemoperationen ohne Überprüfung

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

**Muster für die sichere Handhabung von Parametern:**
+ **Verwenden Sie Parameter in DataFrame Operationen** — Spark DataFrames geht sicher mit Parameterwerten um

  ```
  # SAFE - Use parameters in DataFrame operations
  threshold = int(parameters['threshold'])
  filtered_df = input_df.filter(input_df.value > threshold)
  ```
+ **Parameterwerte validieren** — Stellen Sie vor der Verwendung sicher, dass die Parameter den erwarteten Formaten entsprechen

  ```
  # 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}")
  ```
+ **Zulässige Listen für Parameterwerte verwenden** — Überprüfen Sie die Parameter nach Möglichkeit anhand von zweifelsfrei funktionierenden Werten

  ```
  # 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}")
  ```
+ **Typkonvertierung mit Fehlerbehandlung** — Konvertiere Zeichenkettenparameter sicher in erwartete Typen

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

**Wichtig**  
Denken Sie daran, dass Parameter die Codeüberprüfung umgehen, wenn Job Runner unterschiedliche Werte angeben. Gestalten Sie Ihre Parameterbehandlung so, dass sie unabhängig davon, welche Parameterwerte bereitgestellt werden, sicher funktioniert.

## Vollständiges Beispiel für Parameter
<a name="parameter-examples"></a>

**Example Sicheres Verwenden von Parametern in einem PySpark Skript**  

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