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à.
# Modelli di analisi in AWS Clean Rooms
I modelli di analisi funzionano con[Regola di analisi personalizzata in AWS Clean Rooms](analysis-rules-custom.md). Con un modello di analisi, puoi definire parametri per aiutarti a riutilizzare la stessa interrogazione. AWS Clean Rooms supporta un sottoinsieme di parametrizzazione con valori letterali.
I modelli di analisi sono specifici per la collaborazione. Per ogni collaborazione, i membri possono vedere solo le domande relative a quella collaborazione. Se si prevede di utilizzare la privacy differenziale in una collaborazione, è necessario assicurarsi che i modelli di analisi siano compatibili con la [struttura di query generica](analysis-rules-custom.md#dp-query-structure-syntax) di Differential Privacy. AWS Clean Rooms
Puoi creare un modello di analisi in due modi: usando il codice SQL o usando il codice Python per Spark.
**Topics**
+ [Modelli di analisi SQL](sql-analysis-templates.md)
+ [PySpark modelli di analisi](pyspark-analysis-templates.md)
+ [Modelli di PySpark analisi della risoluzione dei problemi](troubleshooting-pyspark-analysis-templates.md)
# Modelli di analisi SQL
I modelli di analisi SQL consentono di interrogare e analizzare i dati su diversi set di dati all'interno di una collaborazione. Puoi utilizzare questi modelli per eseguire vari tipi di analisi, come identificare le sovrapposizioni di audience e calcolare metriche aggregate.
Con i modelli di analisi SQL, puoi:
+ Scrivere query SQL standard
+ Aggiungi parametri per rendere dinamiche le tue query
+ Controlla l'accesso a colonne e tabelle specifiche
+ Imposta i requisiti di aggregazione per i dati sensibili
+ Definisci i dati di input per la generazione di set di dati sintetici ottimizzati per la privacy per modelli di machine learning (ML) personalizzati
**Topics**
+ [Creazione di un modello di analisi SQL](create-sql-analysis-template.md)
+ [Revisione di un modello di analisi SQL](review-analysis-template.md)
# Creazione di un modello di analisi SQL
**Prerequisiti**
Prima di creare un modello di analisi SQL, è necessario disporre di:
+ Una AWS Clean Rooms collaborazione attiva
+ Accesso ad almeno una tabella configurata nella collaborazione
Per informazioni sulla configurazione delle tabelle in AWS Clean Rooms, vedere[Creazione di una tabella configurata in AWS Clean Rooms](create-configured-table.md).
+ Autorizzazioni per creare modelli di analisi
+ Conoscenza di base della sintassi delle query SQL
La procedura seguente descrive il processo di creazione di un modello di analisi SQL utilizzando la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home).
Per informazioni su come creare un modello di analisi SQL utilizzando AWS SDKs, consulta l'[AWS Clean Rooms API Reference](https://docs.aws.amazon.com/clean-rooms/latest/apireference/Welcome.html).
**Per creare un modello di analisi SQL**
1. Accedi Console di gestione AWS e apri la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home) con il programma Account AWS che fungerà da creatore della collaborazione.
1. Nel riquadro di navigazione a sinistra, scegli **Collaborazioni.**
1. Scegli la collaborazione.
1. Nella scheda **Modelli**, vai alla sezione **Modelli di analisi creati da te**.
1. Scegli **Crea modello di analisi**.
1. Nella pagina **Crea modello di analisi**, per **Dettagli**,
1. Immettere un **nome** per il modello di analisi.
1. (Facoltativo) Inserite una **descrizione**.
1. Per **Formato**, lasciate selezionata l'opzione **SQL**.
1. Per **le tabelle**, visualizza le tabelle configurate associate alla collaborazione.
1. Per **definizione**,
1. Immettete la definizione per il modello di analisi.
1. Scegliete **Importa da** per importare una definizione.
1. (*Facoltativo*) Specificate un parametro nell'editor SQL inserendo i due punti (`:`) davanti al nome del parametro.
Esempio:
`WHERE table1.date + :date_period > table1.date`
1. Se avete aggiunto dei parametri in precedenza, in **Parametri - opzionale**, per ogni **nome di parametro**, scegliete il **tipo** e il **valore predefinito** (opzionale).
1. Per **Dati sintetici**, se desideri generare dati sintetici per l'addestramento del modello, seleziona la casella di controllo **Richiedi che l'output del modello di analisi sia sintetico**.
Per ulteriori informazioni, consulta Generazione di set di dati sintetici [ottimizzati per la privacy](synthetic-data-generation.md).
1. Per la **classificazione delle colonne**, scegli una **colonna** dall'elenco a discesa. Sono necessarie almeno cinque colonne.
1. Scegli una **classificazione** dall'elenco a discesa. Questo identifica il tipo di dati per ogni colonna.
I tipi di classificazione includono:
+ **Numerico**: valori numerici continui come misurazioni o conteggi
+ **Categoriale:** valori o categorie discreti come etichette o tipi
1. **Per rimuovere una colonna, seleziona Rimuovi.**
1. Per aggiungere un'altra colonna, seleziona **Aggiungi un'altra colonna**. Scegli la **colonna** e la **classificazione** dagli elenchi a discesa.
1. Per **Valore predittivo**, scegli una **colonna** dall'elenco a discesa. Questa è la colonna che il modello personalizzato utilizza per la previsione dopo essere stato addestrato sul set di dati sintetico.
1. **Le impostazioni avanzate** consentono di impostare il **livello di privacy e la soglia di** **privacy**. Regola le impostazioni in base alle tue esigenze.
1. Per il **livello di privacy**, inserisci un valore epsilon per determinare la quantità di rumore aggiunta dal modello sintetico per proteggere la privacy nel set di dati generato. Il valore deve essere compreso tra 0,0001 e 10.
+ I valori più bassi aggiungono ulteriore rumore, garantendo una maggiore protezione della privacy ma potenzialmente riducendo l'utilità del modello personalizzato a valle addestrato su questi dati.
+ Valori più alti aggiungono meno rumore, offrendo una maggiore precisione, ma riducendo potenzialmente la protezione della privacy.
Per **Soglia di privacy**, inserisci la probabilità massima consentita che un attacco di inferenza dell'appartenenza possa identificare i membri del set di dati originale. Il valore deve essere compreso tra 50,0 e 100.
+ Un punteggio del 50% indica che un attacco basato sull'inferenza dell'appartenenza non è in grado di distinguere con successo i membri dai non membri meglio di un'ipotesi casuale.
+ Per non avere limiti di privacy, inserisci 100%.
Il valore ottimale dipende dal caso d’uso specifico e dai requisiti in termini di privacy. Se la soglia di privacy viene superata, la creazione del canale di input ML non riesce e non è possibile utilizzare il set di dati sintetico per addestrare un modello.
**avvertimento**
La generazione di dati sintetici protegge dall'inferire attributi individuali se nel set di dati originale sono presenti individui specifici o se sono presenti gli attributi di apprendimento di tali individui. Tuttavia, non impedisce che i valori letterali del set di dati originale, comprese le informazioni di identificazione personale (PII), compaiano nel set di dati sintetico.
Consigliamo di evitare valori nel set di dati di input associati a un solo interessato, poiché potrebbero identificare nuovamente un interessato. Ad esempio, se un solo utente vive in un codice postale, la presenza di quel codice postale nel set di dati sintetico confermerebbe che l'utente era nel set di dati originale. Per mitigare questo rischio è possibile utilizzare tecniche come il tronco di valori ad alta precisione o la sostituzione di cataloghi non comuni con *altri*. Queste trasformazioni possono far parte della query utilizzata per creare il canale di input ML.
1. Se desideri abilitare i **tag** per la risorsa, scegli **Aggiungi nuovo tag** e inserisci la coppia **Chiave** e **Valore**.
1. Scegli **Create** (Crea).
1. Ora sei pronto per informare il tuo collaboratore che può [esaminare un modello di analisi](review-analysis-template.md). (Facoltativo se desideri interrogare i tuoi dati).
# Revisione di un modello di analisi SQL
Dopo che un membro della collaborazione ha creato un SQLanalysis modello, puoi esaminarlo e approvarlo. Una volta approvato, il modello di analisi può essere utilizzato in un'interrogazione in AWS Clean Rooms.
**Nota**
Quando inserite il codice di analisi in una collaborazione, tenete presente quanto segue:
AWS Clean Rooms non convalida né garantisce il comportamento del codice di analisi.
Se devi garantire un determinato comportamento, rivedi direttamente il codice del tuo partner di collaborazione o rivolgiti a un revisore esterno affidabile per esaminarlo.
Nel modello di sicurezza condiviso:
Tu (il cliente) sei responsabile della sicurezza del codice in esecuzione nell'ambiente.
AWS Clean Rooms è responsabile della sicurezza dell'ambiente, garantendo che
viene eseguito solo il codice approvato
sono accessibili solo le tabelle configurate specificate
l'unica destinazione di uscita è il bucket S3 del ricevitore dei risultati.
**Per esaminare un modello di analisi SQL utilizzando la console AWS Clean Rooms**
1. Accedi Console di gestione AWS e apri la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home) con il programma Account AWS che fungerà da creatore della collaborazione.
1. Nel riquadro di navigazione a sinistra, scegli **Collaborazioni.**
1. Scegli la collaborazione.
1. Nella scheda **Modelli**, vai alla sezione **Modelli di analisi creati da altri membri**.
1. La scelta del modello di analisi con **lo stato Può essere eseguito** su **No richiede la tua revisione**.
1. Scegli **Rivedi**.
1. Esamina la **panoramica**, la **definizione** e **i parametri** della regola di analisi (se presenti).
1. Esamina le tabelle configurate elencate in **Tabelle a cui si fa riferimento nella definizione**.
Lo **stato** accanto a ciascuna tabella riporterà la dicitura **Modello non consentito**.
1. Scegliere una tabella .
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/userguide/review-analysis-template.html)
Ora sei pronto per interrogare la tabella configurata utilizzando un modello di analisi SQL. Per ulteriori informazioni, consulta [Esecuzione di query SQL](running-sql-queries.md).
# PySpark modelli di analisi
PySpark i modelli di analisi richiedono uno script utente Python e un ambiente virtuale opzionale per utilizzare librerie personalizzate e open source. Questi file sono chiamati artefatti.
Prima di creare un modello di analisi, devi prima creare gli artefatti e poi archiviarli in un bucket Amazon S3. AWS Clean Rooms utilizza questi artefatti durante l'esecuzione di processi di analisi. AWS Clean Rooms accede agli artefatti solo durante l'esecuzione di un lavoro.
Prima di eseguire qualsiasi codice su un modello di PySpark analisi, AWS Clean Rooms convalida gli artefatti mediante:
+ Verifica della versione specifica dell'oggetto S3 utilizzata durante la creazione del modello
+ Verifica dell'hash SHA-256 dell'artefatto
+ Fallimento di un lavoro in cui gli artefatti sono stati modificati o rimossi
**Nota**
La dimensione massima di tutti gli artefatti combinati per un determinato modello di PySpark analisi è 1 GB. AWS Clean Rooms
## Sicurezza per i modelli di analisi PySpark
Per preservare un ambiente di elaborazione sicuro, AWS Clean Rooms utilizza un'architettura di elaborazione a due livelli per isolare il codice utente dalle operazioni di sistema. Questa architettura si basa sulla tecnologia Amazon EMR Serverless Fine Grained Access Control, nota anche come Membrane. Per ulteriori informazioni, consulta [Membrane: controlli di accesso ai dati sicuri e performanti in Apache Spark in](https://www.amazon.science/publications/membrane-safe-and-performant-data-access-controls-in-apache-spark-in-the-presence-of-imperative-code) presenza di codice imperativo.
I componenti dell'ambiente di calcolo sono suddivisi in uno spazio utente e uno di sistema separati. Lo spazio utente esegue il PySpark codice nel modello di PySpark analisi. AWS Clean Rooms utilizza lo spazio di sistema per consentire l'esecuzione del processo, incluso l'utilizzo dei ruoli di servizio forniti dai clienti per leggere i dati per eseguire il processo e l'implementazione della colonna allowlist. Come risultato di questa architettura, il PySpark codice del cliente che influisce sullo spazio del sistema, che potrebbe includere un numero limitato di Spark SQL e PySpark DataFrames APIs, viene bloccato.
## PySpark limitazioni in AWS Clean Rooms
Quando i clienti inviano un modello di PySpark analisi approvato, lo AWS Clean Rooms esegue nel proprio ambiente di elaborazione sicuro a cui nessun cliente può accedere. L'ambiente di elaborazione implementa un'architettura di elaborazione con uno spazio utente e uno spazio di sistema per preservare un ambiente di elaborazione sicuro. Per ulteriori informazioni, consulta [Sicurezza per i modelli di analisi PySpark](#pyspark-analysis-templates-security).
Considerate le seguenti limitazioni prima di utilizzarlo. PySpark AWS Clean Rooms
**Limitazioni**
+ Sono DataFrame supportate solo le uscite
+ Una singola sessione Spark per esecuzione del job
**Caratteristiche non supportate**
+ **Gestione dei dati**
+ Formati di tabelle Iceberg
+ LakeFormation tabelle gestite
+ Resilient Distributed Dataset (RDD)
+ Streaming di Spark
+ Controllo degli accessi per colonne annidate
+ **Funzioni ed estensioni personalizzate**
+ Funzioni di tabella definite dall'utente () UDTFs
+ Alveare UDFs
+ Classi personalizzate in funzioni definite dall'utente
+ Origini dati personalizzate
+ File JAR aggiuntivi per:
+ Estensioni Spark
+ Connettori
+ Configurazioni Metastore
+ **Monitoraggio e analisi**
+ Registrazione Spark
+ Interfaccia utente Spark
+ Comandi `ANALYZE TABLE`
**Importante**
Queste limitazioni servono a mantenere l'isolamento di sicurezza tra gli spazi utente e di sistema.
Tutte le restrizioni si applicano indipendentemente dalla configurazione della collaborazione.
Gli aggiornamenti futuri potrebbero aggiungere il supporto per funzionalità aggiuntive basate su valutazioni di sicurezza.
## Best practice
Per la creazione di modelli di PySpark analisi, consigliamo le seguenti best practice.
+ Progetta i tuoi modelli di analisi pensando [PySpark limitazioni in AWS Clean Rooms](#pyspark-limitations) a questo.
+ Testa prima il codice in un ambiente di sviluppo.
+ Utilizza esclusivamente DataFrame le operazioni supportate.
+ Pianifica la tua struttura di output in modo che funzioni con DataFrame limitazioni.
Consigliamo le seguenti best practice per la gestione degli artefatti
+ Conserva tutti gli artefatti del modello di PySpark analisi in un bucket o prefisso S3 dedicato.
+ Usa una denominazione chiara delle versioni per le diverse versioni degli artefatti.
+ Crea nuovi modelli di analisi quando sono necessari aggiornamenti degli artefatti.
+ Mantieni un inventario dei modelli che utilizzano le versioni degli artefatti.
Per ulteriori informazioni su come scrivere codice Spark, consulta quanto segue:
+ [Esempi di Apache Spark](https://spark.apache.org/examples.html)
+ [Scrivi un'applicazione Spark](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-application.html) nella *Amazon EMR Release Guide*
+ [Tutorial: scrivere uno script AWS Glue per Spark](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-intro-tutorial.html) *nella Guida per l'utente AWS Glue *
I seguenti argomenti spiegano come creare script utente e librerie Python prima di creare e rivedere il modello di analisi.
**Topics**
+ [Sicurezza per i modelli di analisi PySpark](#pyspark-analysis-templates-security)
+ [PySpark limitazioni in AWS Clean Rooms](#pyspark-limitations)
+ [Best practice](#python-best-practices)
+ [Creazione di uno script utente](create-user-script.md)
+ [Utilizzo dei parametri nei modelli di PySpark analisi](pyspark-parameter-handling.md)
+ [Creazione di un ambiente virtuale (opzionale)](create-virtual-environment.md)
+ [Memorizzazione di uno script utente e di un ambiente virtuale in S3](store-artifacts-in-s3.md)
+ [Creazione di un modello di analisi PySpark](create-pyspark-analysis-template.md)
+ [Revisione di un modello di PySpark analisi](review-pyspark-analysis-template.md)
# Creazione di uno script utente
Lo script utente deve contenere una funzione entrypoint (in altre parole, un gestore). È possibile assegnare un nome al file di script utente con qualsiasi nome di file Python valido.
La procedura seguente descrive come creare uno script utente per definire le funzionalità principali dell'analisi. PySpark
**Prerequisiti**
+ PySpark 1.0 (corrisponde a Python 3.11 e Spark 3.5.3)
+ I set di dati in Amazon S3 possono essere letti solo come associazioni di tabelle configurate nella sessione Spark da te definita.
+ Il tuo codice non può chiamare direttamente Amazon S3 e AWS Glue
+ Il tuo codice non può effettuare chiamate di rete
**Per creare uno script utente**
1. Apri un editor di testo o un ambiente di sviluppo integrato (IDE) a tua scelta.
Puoi usare qualsiasi editor di testo o IDE (come Visual Studio Code o Notepad\$1\$1) che supporti i file Python. PyCharm
1. Crea un nuovo file Python con un nome a tua scelta (ad esempio,**my\$1analysis.py**).
1. Definite una funzione entrypoint che accetti un parametro dell'oggetto contestuale.
```
def entrypoint(context)
```
Il parametro `context` object è un dizionario che fornisce l'accesso ai componenti Spark essenziali, alle tabelle di riferimento e ai parametri di analisi. Contiene:
Accesso alla sessione Spark tramite `context['sparkSession']`
Tabelle referenziate tramite `context['referencedTables']`
Parametri di analisi tramite `context['analysisParameters']` (se i parametri sono definiti nel modello)
1. Definisci i risultati della funzione entrypoint:
```
return results
```
`results`Deve restituire un oggetto contenente un dizionario dei risultati dei nomi di file in un output. DataFrame
**Nota**
AWS Clean Rooms scrive automaticamente gli DataFrame oggetti nel bucket S3 del ricevitore dei risultati.
1. Ora sei pronto per:
1. Memorizza questo script utente in S3. Per ulteriori informazioni, consulta [Memorizzazione di uno script utente e di un ambiente virtuale in S3](store-artifacts-in-s3.md).
1. Crea l'ambiente virtuale opzionale per supportare eventuali librerie aggiuntive richieste dallo script utente. Per ulteriori informazioni, consulta [Creazione di un ambiente virtuale (opzionale)](create-virtual-environment.md).
**Example Esempio 1**
```
# File name: my_analysis.py
def entrypoint(context):
try:
# Access Spark session
spark = context['sparkSession']
# Access input tables
input_table1 = context['referencedTables']['table1_name']
input_table2 = context['referencedTables']['table2_name']
# Example data processing operations
output_df1 = input_table1.select("column1", "column2")
output_df2 = input_table2.join(input_table1, "join_key")
output_df3 = input_table1.groupBy("category").count()
# Return results - each key creates a separate output folder
return {
"results": {
"output1": output_df1, # Creates output1/ folder
"output2": output_df2, # Creates output2/ folder
"analysis_summary": output_df3 # Creates analysis_summary/ folder
}
}
except Exception as e:
print(f"Error in main function: {str(e)}")
raise e
```
La struttura delle cartelle di questo esempio è la seguente:
```
analysis_results/
│
├── output1/ # Basic selected columns
│ ├── part-00000.parquet
│ └── _SUCCESS
│
├── output2/ # Joined data
│ ├── part-00000.parquet
│ └── _SUCCESS
│
└── analysis_summary/ # Aggregated results
├── part-00000.parquet
└── _SUCCESS
```
**Example Esempio 2**
```
def entrypoint(context):
try:
# Get DataFrames from context
emp_df = context['referencedTables']['employees']
dept_df = context['referencedTables']['departments']
# Apply Transformations
emp_dept_df = emp_df.join(
dept_df,
on="dept_id",
how="left"
).select(
"emp_id",
"name",
"salary",
"dept_name"
)
# Return Dataframes
return {
"results": {
"outputTable": emp_dept_df
}
}
except Exception as e:
print(f"Error in entrypoint function: {str(e)}")
raise e
```
# Utilizzo dei parametri nei modelli di PySpark analisi
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
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
**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
**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
```
# Creazione di un ambiente virtuale (opzionale)
Se hai delle librerie aggiuntive richieste dallo script utente, hai la possibilità di creare un ambiente virtuale per archiviare tali librerie. Se non hai bisogno di librerie aggiuntive, puoi saltare questo passaggio.
Quando lavori con librerie con estensioni native, tieni PySpark presente che AWS Clean Rooms funziona su Linux con ARM64 architettura.
La procedura seguente dimostra come creare un ambiente virtuale utilizzando un comando CLI di base.
**Per creare un ambiente virtuale**
1. Aprire un terminale o un prompt dei comandi.
1. Aggiungi il seguente contenuto:
```
# create and activate a python virtual environment
python3 -m venv pyspark_venvsource
source pyspark_venvsource/bin/activate
# install the python packages
pip3 install pandas # add packages here
# package the virtual environment into an archive
pip3 install venv-pack
venv-pack -f -o pyspark_venv.tar.gz
# optionally, remove the virtual environment directory
deactivate
rm -fr pyspark_venvsource
```
1. Ora sei pronto per archiviare questo ambiente virtuale in S3. Per ulteriori informazioni, consulta [Memorizzazione di uno script utente e di un ambiente virtuale in S3](store-artifacts-in-s3.md).
Per ulteriori informazioni sull'utilizzo di Docker e Amazon ECR, consulta la [Amazon ECRUser ](https://docs.aws.amazon.com/AmazonECR/latest/userguide/) Guide.
# Memorizzazione di uno script utente e di un ambiente virtuale in S3
La procedura seguente spiega come archiviare uno script utente e un ambiente virtuale opzionale in Amazon S3. Completa questo passaggio prima di creare un modello di PySpark analisi.
**Importante**
Non modificate o rimuovete artefatti (script utente o ambienti virtuali) dopo aver creato un modello di analisi.
In questo modo sarà possibile:
Fai fallire tutti i lavori di analisi futuri che utilizzano questo modello.
Richiede la creazione di un nuovo modello di analisi con nuovi artefatti.
Non influisce sui lavori di analisi completati in precedenza
**Prerequisiti**
+ E Account AWS con le autorizzazioni appropriate
+ Un file di script utente (ad esempio`my_analysis.py`)
+ (Facoltativo, se ne esiste uno) Un pacchetto di ambiente virtuale (`.tar.gz`file)
+ Accesso per creare o modificare ruoli IAM
------
#### [ Console ]
**Per archiviare uno script utente e un ambiente virtuale in S3 utilizzando la console:**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Crea un nuovo bucket S3 o usane uno esistente.
1. Abilita il controllo delle versioni per il bucket.
1. Seleziona il tuo bucket.
1. Scegli **Properties (Proprietà)**.
1. **Nella sezione **Bucket Versioning**, scegli Modifica.**
1. Seleziona **Abilita** e salva le modifiche.
1. Carica i tuoi artefatti e abilita l'hash SHA-256.
1. Vai al tuo bucket.
1. Scegli **Carica**.
1. Scegli **Aggiungi file** e aggiungi il tuo file di script utente.
1. (Facoltativo, se ne esiste uno) Aggiungi il tuo **file.tar.gz.**
1. **Espandi Proprietà.**
1. In **Checksums**, per la **funzione Checksum**, selezionare. **SHA256**
1. Scegli **Carica**.
1. Ora sei pronto per creare un PySpark modello di analisi.
------
#### [ CLI ]
**Per archiviare lo script utente e l'ambiente virtuale in S3 utilizzando: AWS CLI**
1. Esegui il comando seguente:
```
aws s3 cp --checksum-algorithm sha256 pyspark_venv.tar.gz s3://ARTIFACT-BUCKET/EXAMPLE-PREFIX/
```
1. Ora sei pronto per creare un modello di PySpark analisi.
------
**Nota**
Se è necessario aggiornare lo script o l'ambiente virtuale:
Carica la nuova versione come oggetto separato.
Crea un nuovo modello di analisi utilizzando i nuovi artefatti.
Deprecate il vecchio modello.
Conserva gli artefatti originali in S3 se il vecchio modello potrebbe essere ancora necessario.
# Creazione di un modello di analisi PySpark
**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.
**Prerequisiti**
Prima di creare un modello di PySpark analisi, è necessario disporre di:
+ Un'appartenenza a una AWS Clean Rooms collaborazione attiva
+ Accesso ad almeno una tabella configurata nella collaborazione attiva
+ Autorizzazioni per creare modelli di analisi
+ Uno script utente Python e un ambiente virtuale creati e archiviati in S3
+ Il bucket S3 ha il controllo delle versioni abilitato. Per ulteriori informazioni, consulta [Utilizzo del controllo delle versioni](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) nei bucket S3
+ Il bucket S3 può calcolare i checksum SHA-256 per gli artefatti caricati. Per ulteriori informazioni, [consulta Utilizzo dei checksum](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html)
+ Autorizzazioni per leggere il codice da un bucket S3
Per informazioni sulla creazione del ruolo di servizio richiesto, consulta. [Crea un ruolo di servizio per leggere il codice da un bucket S3 (ruolo modello di PySpark analisi)](setting-up-roles.md#create-role-pyspark-analysis-template)
La procedura seguente descrive il processo di creazione di un modello di PySpark analisi utilizzando la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home). Si presuppone che tu abbia già creato uno script utente e dei file di ambiente virtuale e che tu abbia archiviato lo script utente e i file di ambiente virtuale in un bucket Amazon S3.
**Nota**
Il membro che crea il modello di PySpark analisi deve essere anche il membro che riceve i risultati.
Per informazioni su come creare un modello di PySpark analisi utilizzando il AWS SDKs, consulta l'[AWS Clean Rooms API Reference](https://docs.aws.amazon.com/clean-rooms/latest/apireference/Welcome.html).
**Per creare un modello di PySpark analisi**
1. Accedi Console di gestione AWS e apri la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home) con il programma Account AWS che fungerà da creatore della collaborazione.
1. Nel riquadro di navigazione a sinistra, scegli **Collaborazioni.**
1. Scegli la collaborazione.
1. Nella scheda **Modelli**, vai alla sezione **Modelli di analisi creati da te**.
1. Scegli **Crea modello di analisi**.
1. Nella pagina **Crea modello di analisi**, per **Dettagli**,
1. Immettere un **nome** per il modello di analisi.
1. (Facoltativo) Inserite una **descrizione**.
1. Per **Formato**, scegli l'**PySpark**opzione.
1. Per **Definizione**,
1. Esamina i **prerequisiti** e assicurati che ogni prerequisito sia soddisfatto prima di continuare.
1. **Per il **file Entry Point**, inserisci il bucket S3 o scegli Browse S3.**
1. **(Facoltativo) Per il **file Libraries**, inserisci il bucket S3 o scegli Browse S3.**
1. Per **i parametri: facoltativo**, se desideri aggiungere parametri per rendere riutilizzabile il modello di analisi:
1. Scegli **Add parameter (Aggiungi parametro)**.
1. Immettete un **nome per il parametro**.
I nomi dei parametri devono iniziare con una lettera o un carattere di sottolineatura, seguiti da caratteri alfanumerici o caratteri di sottolineatura.
1. Per **Tipo**, **STRING** viene selezionato automaticamente come unico tipo supportato per i modelli di analisi. PySpark
1. (Facoltativo) Inserite un **valore predefinito** per il parametro.
Se fornite un valore predefinito, i job runner possono utilizzare questo valore durante l'esecuzione dei job senza fornire esplicitamente un valore di parametro.
1. Per aggiungere altri parametri, scegli **Aggiungi un altro parametro** e ripeti i passaggi precedenti.
**Nota**
È possibile definire fino a 50 parametri per modello di PySpark analisi. Il valore di ogni parametro può contenere fino a 1.000 caratteri.
1. Per le **tabelle a cui si fa riferimento nella definizione**,
+ Se tutte le tabelle a cui si fa riferimento nella definizione sono state associate alla collaborazione:
+ Lasciate selezionata la casella di controllo **Tutte le tabelle a cui si fa riferimento nella definizione sono state associate alla collaborazione**.
+ In **Tabelle associate alla collaborazione**, scegli tutte le tabelle associate a cui si fa riferimento nella definizione.
+ Se tutte le tabelle a cui si fa riferimento nella definizione non sono state associate alla collaborazione:
+ Deseleziona la casella di controllo **Tutte le tabelle a cui si fa riferimento nella definizione sono state associate alla collaborazione**.
+ In **Tabelle associate alla collaborazione**, scegli tutte le tabelle associate a cui si fa riferimento nella definizione.
+ In **Tabelle che verranno associate in seguito**, inserisci un nome per la tabella.
+ **Scegli Elenca un'altra tabella** per elencare un'altra tabella.
1. Per la **configurazione dei messaggi di errore**, scegli una delle seguenti opzioni:
+ **Messaggi di errore di base**: restituisce messaggi di errore di base senza esporre i dati sottostanti. Consigliato per carichi di lavoro di produzione.
+ **Messaggi di errore dettagliati: restituisce messaggi** di errore dettagliati per una risoluzione più rapida dei problemi. Consigliato in ambienti di sviluppo e test. Può esporre dati sensibili, incluse le informazioni di identificazione personale (PII).
**Nota**
Quando si utilizzano **messaggi di errore dettagliati**, tutti i membri del fornitore di dati devono approvare questa impostazione per il modello.
1. Specificate le autorizzazioni di **accesso al servizio** selezionando un **nome di ruolo di servizio esistente** dall'elenco a discesa.
1. L'elenco dei ruoli viene visualizzato se si dispone delle autorizzazioni per elencare i ruoli.
Se non disponi delle autorizzazioni per elencare i ruoli, puoi inserire l'Amazon Resource Name (ARN) del ruolo che desideri utilizzare.
1. Visualizza il ruolo del servizio scegliendo il link esterno **View in IAM**.
Se non ci sono ruoli di servizio esistenti, l'opzione **Usa un ruolo di servizio esistente** non è disponibile.
Per impostazione predefinita, AWS Clean Rooms non tenta di aggiornare la politica esistente sui ruoli per aggiungere le autorizzazioni necessarie.
**Nota**
AWS Clean Rooms richiede le autorizzazioni per eseguire interrogazioni in base alle regole di analisi. Per ulteriori informazioni sulle autorizzazioni per AWS Clean Rooms, vedere. [AWS politiche gestite per AWS Clean Rooms](security-iam-awsmanpol.md)
Se il ruolo non dispone di autorizzazioni sufficienti per AWS Clean Rooms, riceverai un messaggio di errore che indica che il ruolo non dispone di autorizzazioni sufficienti per. AWS Clean Rooms La politica del ruolo deve essere aggiunta prima di procedere.
Se non riesci a modificare la politica del ruolo, ricevi un messaggio di errore che indica che non AWS Clean Rooms riesci a trovare la politica per il ruolo di servizio.
1. Se desideri abilitare i **tag** per la risorsa della tabella configurata, scegli **Aggiungi nuovo tag** e inserisci la coppia **Chiave** e **Valore**.
1. Scegli **Create** (Crea).
1. Ora sei pronto per informare il tuo collaboratore che può [esaminare un modello di analisi](review-analysis-template.md). (Facoltativo se desideri interrogare i tuoi dati).
**Importante**
Non modificate o rimuovete artefatti (script utente o ambienti virtuali) dopo aver creato un modello di analisi.
In questo modo sarà possibile:
Fai fallire tutti i lavori di analisi futuri che utilizzano questo modello.
Richiede la creazione di un nuovo modello di analisi con nuovi artefatti.
Non influisce sui lavori di analisi completati in precedenza.
# Revisione di un modello di PySpark analisi
Quando un altro membro crea un modello di analisi nell'ambito della collaborazione, è necessario esaminarlo e approvarlo prima che possa essere utilizzato.
La procedura seguente mostra come esaminare un modello di PySpark analisi, incluse le regole, i parametri e le tabelle di riferimento. In qualità di membro della collaborazione, valuterai se il modello è in linea con gli accordi di condivisione dei dati e i requisiti di sicurezza.
Una volta approvato, il modello di analisi può essere utilizzato in un job in AWS Clean Rooms.
**Nota**
Quando inserite il codice di analisi in una collaborazione, tenete presente quanto segue:
AWS Clean Rooms non convalida né garantisce il comportamento del codice di analisi.
Se devi garantire un determinato comportamento, rivedi direttamente il codice del tuo partner di collaborazione o rivolgiti a un revisore esterno affidabile per esaminarlo.
AWS Clean Rooms garantisce che gli hash SHA-256 del codice elencato nel modello di PySpark analisi corrispondano al codice in esecuzione nell'ambiente di analisi. PySpark
AWS Clean Rooms non esegue alcuna verifica o analisi di sicurezza delle librerie aggiuntive introdotte nell'ambiente.
Nel modello di sicurezza condiviso:
Tu (il cliente) sei responsabile della sicurezza del codice in esecuzione nell'ambiente.
L'utente (il cliente) è responsabile dell'impostazione della configurazione appropriata dei messaggi di errore per l'ambiente.
AWS Clean Rooms è responsabile della sicurezza dell'ambiente, garantendo che
viene eseguito solo il codice approvato
sono accessibili solo le tabelle configurate specificate
l'unica destinazione di uscita è il bucket S3 del ricevitore dei risultati.
AWS Clean Rooms genera hash SHA-256 dello script utente e dell'ambiente virtuale da esaminare. Tuttavia, lo script utente e le librerie effettivi non sono direttamente accessibili all'interno. AWS Clean Rooms
Per verificare che lo script utente e le librerie condivise siano gli stessi a cui si fa riferimento nel modello di analisi, è possibile creare un hash SHA-256 dei file condivisi e confrontarlo con l'hash del modello di analisi creato da. AWS Clean Rooms Gli hash del codice eseguito saranno presenti anche nei log dei processi.
**Prerequisiti**
+ Sistema operativo Linux/Unix o sottosistema Windows per Linux (WSL)
+ File di script utente di cui desideri eseguire l'hash
+ Richiedi che il creatore del modello di analisi condivida il file tramite un canale sicuro.
+ L'hash del modello di analisi creato da AWS Clean Rooms
**Per rivedere un modello di PySpark analisi utilizzando la console AWS Clean Rooms**
1. Accedi Console di gestione AWS e apri la [AWS Clean Rooms console](https://console.aws.amazon.com/cleanrooms/home) con il programma Account AWS che fungerà da creatore della collaborazione.
1. Nel riquadro di navigazione a sinistra, scegli **Collaborazioni.**
1. Scegli la collaborazione.
1. Nella scheda **Modelli**, vai alla sezione **Modelli di analisi creati da altri membri**.
1. La scelta del modello di analisi con **lo stato Può essere eseguito** su **No richiede la tua revisione**.
1. Scegli **Rivedi**.
1. Esamina la **panoramica**, la **definizione** e **i parametri** della regola di analisi (se presenti).
**Nota**
I parametri consentono ai responsabili dell'analisi di inviare valori diversi al momento dell'invio. Se un modello di analisi supporta i parametri, esaminate come i valori dei parametri vengono utilizzati nel codice del vostro partner di collaborazione per assicurarvi che soddisfi i vostri requisiti.
1. Verifica che lo script utente e le librerie condivisi siano gli stessi a cui si fa riferimento nel modello di analisi.
1. Crea un hash SHA-256 dei file condivisi e confrontalo con l'hash del modello di analisi creato da. AWS Clean Rooms
È possibile generare un hash accedendo alla directory contenente il file di script utente e quindi eseguendo il comando seguente:
```
sha256sum your_script_filename.py
```
Output di esempio:
```
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 my_analysis.py
```
1. In alternativa, puoi utilizzare le funzionalità di checksum di Amazon S3. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html) *User Guide*.
1. Un'altra alternativa è visualizzare gli hash del codice eseguito nei log dei lavori.
1. Esamina le tabelle configurate elencate in Tabelle a cui si **fa riferimento** nella definizione.
Lo **stato** accanto a ciascuna tabella riporterà la dicitura **Modello non consentito**.
1. Scegliere una tabella .
1. Per approvare il modello di analisi, scegli **Consenti modello sulla tabella.** Conferma l'approvazione selezionando **Consenti**.
1. Per rifiutare l'approvazione, scegli **Non consentire**.
Se hai scelto di approvare il modello di analisi, il membro che può eseguire i job può ora eseguire un PySpark job su una tabella configurata utilizzando un modello di PySpark analisi. Per ulteriori informazioni, consulta [PySpark Lavori in corso](run-jobs.md).
# Modelli di PySpark analisi della risoluzione dei problemi
Quando si eseguono lavori utilizzando modelli di PySpark analisi, è possibile che si verifichino errori durante l'inizializzazione o l'esecuzione dei processi. Questi errori si riferiscono in genere alla configurazione degli script, alle autorizzazioni di accesso ai dati o alla configurazione dell'ambiente.
Per ulteriori informazioni sulle PySpark limitazioni, vedere. [PySpark limitazioni in AWS Clean Rooms](pyspark-analysis-templates.md#pyspark-limitations)
**Topics**
+ [Risoluzione dei problemi relativi al codice](#troubleshoot-your-code)
+ [Il processo del modello di analisi non si avvia](#troubleshooting_analysis_template_job_fails_to_start)
+ [Il processo del modello di analisi si avvia ma fallisce durante l'elaborazione](#analysis-template-job-failes-to-run)
+ [La configurazione dell'ambiente virtuale non riesce](#virtual-environment-setup-fails)
## Risoluzione dei problemi relativi al codice
Per aiutarti a sviluppare e risolvere i problemi del codice, ti consigliamo di eseguire la simulazione AWS Clean Rooms in modo personalizzato Account AWS abilitando i **messaggi di errore dettagliati** e l'esecuzione dei job utilizzando i tuoi dati di test.
Puoi anche eseguire la simulazione PySpark AWS Clean Rooms in Amazon EMR Serverless con i seguenti passaggi. Presenterà piccole differenze rispetto PySpark a AWS Clean Rooms, ma riguarda principalmente il modo in cui il codice può essere eseguito.
**Per eseguire la simulazione PySpark AWS Clean Rooms in EMR Serverless**
1. Crea un set di dati in Amazon S3, catalogalo in e configura AWS Glue Data Catalog le autorizzazioni di Lake Formation.
1. Registra la sede S3 con Lake Formation utilizzando un ruolo personalizzato.
1. Crea un'istanza Amazon EMR Studio se non ne hai già una (Amazon EMR Studio è necessario per usare Amazon EMR Serverless).
1. Crea un'app EMR Serverless
+ Seleziona la versione di rilascio emr-7.7.0.
+ ARM64 Seleziona l'architettura.
+ Scegli **Usa impostazioni personalizzate**.
+ Disattiva la capacità preinizializzata.
+ Se prevedi di eseguire un lavoro interattivo, seleziona **Endpoint interattivo** > **Abilita endpoint per EMR studio.**
+ Seleziona **Configurazioni aggiuntive** > **Usa Lake Formation per un controllo granulare degli accessi**.
+ Crea l'applicazione.
1. Usa EMR-S tramite i notebook EMR-Studio o l'API. `StartJobRun`
## Il processo del modello di analisi non si avvia
### Cause comuni
I processi del modello di analisi possono fallire immediatamente all'avvio a causa di tre problemi di configurazione principali:
+ Denominazione errata dello script che non corrisponde al formato richiesto
+ Funzione entrypoint mancante o formattata in modo errato nello script utente
+ Versione Python incompatibile nell'ambiente virtuale
### Risoluzione
**Per risolvere:**
1. Verifica lo script utente:
1. Verifica che lo script utente abbia un nome di file Python valido.
I nomi di file Python validi utilizzano lettere minuscole, caratteri di sottolineatura per separare le parole e l'estensione.py.
1. Verifica la funzione entrypoint. Se lo script utente non ha una funzione entrypoint, aggiungine una.
1. Apri lo script utente.
1. Aggiungi questa funzione entrypoint:
```
def entrypoint(context):
# Your analysis code here
```
1. Assicurati che il nome della funzione sia scritto esattamente come. `entrypoint`
1. Verificate che la funzione accetti il `context` parametro.
1. Verifica la compatibilità della versione di Python:
1. Verifica che il tuo ambiente virtuale utilizzi Python 3.9 o 3.11.
1. Per verificare la tua versione, esegui: `python --version`
1. Se necessario, aggiorna il tuo ambiente virtuale:
```
conda create -n analysis-env python=3.9
conda activate analysis-env
```
### Prevenzione
+ Utilizza il codice iniziale del modello di analisi fornito che include la struttura di file corretta.
+ Configura un ambiente virtuale dedicato con Python 3.9 o 3.11 per tutti i modelli di analisi.
+ Testa il modello di analisi localmente utilizzando lo strumento di convalida dei modelli prima di inviare i lavori.
+ Implementa CI/CD controlli per verificare la denominazione degli script e i requisiti delle funzioni entrypoint.
## Il processo del modello di analisi si avvia ma fallisce durante l'elaborazione
### Cause comuni
I processi di analisi possono fallire durante l'esecuzione per i seguenti motivi di sicurezza e formattazione:
+ Tentativi di accesso diretto non autorizzati a AWS servizi come Amazon S3 o AWS Glue
+ Restituzione dell'output in formati errati che non corrispondono alle specifiche richieste DataFrame
+ Chiamate di rete bloccate a causa di restrizioni di sicurezza nell'ambiente di esecuzione
### Risoluzione
**Risolvere**
1. Rimuovere l'accesso diretto al AWS servizio:
1. Cerca nel tuo codice le importazioni e le chiamate dirette ai AWS servizi.
1. Sostituisci l'accesso diretto a S3 con i metodi di sessione Spark forniti.
1. Usa solo tabelle preconfigurate tramite l'interfaccia di collaborazione.
1. Formatta correttamente gli output:
1. Verifica che tutte le uscite siano Spark. DataFrames
1. Aggiorna la dichiarazione di reso in modo che corrisponda a questo formato:
```
return {
"results": {
"output1": dataframe1
}
}
```
1. Rimuovi tutti gli oggetti non DataFrame restituiti.
1. Rimuovi le chiamate di rete:
1. Identifica e rimuovi eventuali chiamate API esterne.
1. Rimuovi eventuali urllib, richieste o librerie di rete simili.
1. Rimuovi eventuali connessioni socket o codice client HTTP.
### Prevenzione
+ Utilizza il codice linter fornito per verificare la presenza di AWS importazioni e chiamate di rete non autorizzate.
+ Testa i lavori nell'ambiente di sviluppo in cui le restrizioni di sicurezza corrispondono alla produzione.
+ Segui il processo di convalida dello schema di output prima di distribuire i lavori.
+ Consulta le linee guida sulla sicurezza per i modelli di accesso ai servizi approvati.
## La configurazione dell'ambiente virtuale non riesce
### Cause comuni
Gli errori di configurazione dell'ambiente virtuale si verificano in genere a causa di:
+ Architettura della CPU non corrispondente tra ambienti di sviluppo ed esecuzione
+ Problemi di formattazione del codice Python che impediscono la corretta inizializzazione dell'ambiente
+ Configurazione errata dell'immagine di base nelle impostazioni del contenitore
### Risoluzione
**Risolvere**
1. Configura l'architettura corretta:
1. Controlla la tua architettura attuale con `uname -m. `
1. Aggiorna il tuo Dockerfile per specificare: ARM64
```
FROM --platform=linux/arm64 public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
```
1. Ricostruisci il tuo contenitore con `docker build --platform=linux/arm64.`
1. Correggi l'indentazione in Python:
1. Esegui un formattatore di codice Python come nei tuoi file `black` di codice.
1. Verifica l'uso coerente degli spazi o delle schede (non di entrambi).
1. Controlla l'indentazione di tutti i blocchi di codice:
```
def my_function():
if condition:
do_something()
return result
```
1. Usa un IDE con evidenziazione dell'indentazione in Python.
1. Convalida la configurazione dell'ambiente:
1. Esegui `python -m py_compile your_script.py` per verificare la presenza di errori di sintassi.
1. Verifica l'ambiente localmente prima della distribuzione.
1. Verifica che tutte le dipendenze siano elencate in`requirements.txt`.
### Prevenzione
+ Usa Visual Studio Code o PyCharm con i plugin di formattazione Python
+ Configura gli hook di pre-commit per eseguire automaticamente i formattatori di codice
+ Crea e testa ambienti localmente utilizzando l'immagine di base fornita ARM64
+ Implementa il controllo automatico dello stile del codice nella tua CI/CD pipeline