Arbeiten mit Parametern in PySpark Analysevorlagen - AWS Clean Rooms
Zugreifen auf ParameterBewährte Methoden für die ParametersicherheitVollständiges Beispiel für Parameter

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

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

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

Beispiel 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

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

Beispiel 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