

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à.

# Risoluzione dei problemi con Amazon DataZone
<a name="troubleshooting-datazone"></a>

Se riscontri problemi di accesso negato o difficoltà simili quando lavori con Amazon, DataZone consulta gli argomenti di questa sezione.

## Risoluzione dei problemi relativi alle autorizzazioni di AWS Lake Formation per Amazon DataZone
<a name="troubleshooting-lake-formation-permissions"></a>

Questa sezione contiene istruzioni per la risoluzione dei problemi che potresti riscontrare quando lo fai[Configura le autorizzazioni di Lake Formation per Amazon DataZone](lake-formation-permissions-for-datazone.md). 


| Messaggio di errore nel Data Portal | Risoluzione | 
| --- | --- | 
| Impossibile assumere il ruolo di accesso ai dati.  | Questo errore viene visualizzato quando Amazon non DataZone è in grado di presumere **AmazonDataZoneGlueDataAccessRole**che tu abbia utilizzato per abilitarlo **DefaultDataLakeBlueprint**nel tuo account. Per risolvere il problema, accedi alla console AWS IAM dell'account in cui si trova il tuo asset di dati e assicurati che **AmazonDataZoneGlueDataAccessRole**abbia il giusto rapporto di fiducia con il responsabile del DataZone servizio Amazon. Per ulteriori informazioni, consulta [AmazonDataZoneGlueAccess- <region>- <domainId>](glue-manage-access-role.md)  | 
| Il ruolo di accesso ai dati non dispone delle autorizzazioni necessarie per leggere i metadati della risorsa a cui stai tentando di sottoscrivere.  | Questo errore viene visualizzato quando Amazon assume DataZone correttamente il **AmazonDataZoneGlueDataAccessRole**ruolo, ma il ruolo non dispone delle autorizzazioni necessarie. Per risolvere il problema, accedi alla console AWS IAM dell'account in cui si trova il tuo asset di dati e assicurati che al ruolo sia **AmazonDataZoneGlueManageAccessRolePolicy**associato. Per ulteriori informazioni, consulta [AmazonDataZoneGlueAccess- <region>- <domainId>](glue-manage-access-role.md). | 
| L'asset è un collegamento a una risorsa. Amazon DataZone non supporta gli abbonamenti ai link alle risorse. | Questo errore viene visualizzato quando la risorsa che stai tentando di pubblicare su Amazon DataZone è un link di risorsa a una tabella AWS Glue.  | 
| L'asset non è gestito da AWS Lake Formation. | Questo errore indica che le autorizzazioni di AWS Lake Formation non sono applicate alla risorsa che desideri pubblicare. Questo può accadere nei seguenti casi.[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/datazone/latest/userguide/troubleshooting-datazone.html) | 
| Il ruolo Data Access non dispone delle autorizzazioni Lake Formation necessarie per concedere l'accesso a questa risorsa. | Questo errore indica che il file **AmazonDataZoneGlueDataAccessRole**che stai utilizzando per abilitare il contenuto **DefaultDataLakeBlueprint**nel tuo account non dispone delle autorizzazioni necessarie DataZone ad Amazon per gestire le autorizzazioni sulla risorsa pubblicata. Puoi risolvere il problema aggiungendolo **AmazonDataZoneGlueDataAccessRole**come amministratore di AWS Lake Formation o concedendo le seguenti autorizzazioni **AmazonDataZoneGlueDataAccessRole**alla risorsa che desideri pubblicare.[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/datazone/latest/userguide/troubleshooting-datazone.html) | 

## Risoluzione dei problemi relativi al collegamento degli asset Amazon DataZone Lineage con set di dati upstream
<a name="troubleshooting-lineage"></a>

Questa sezione contiene istruzioni per la risoluzione dei problemi che potresti riscontrare con Amazon DataZone Lineage. Per alcuni degli AWS Glue eventi open lineage run relativi ad Amazon Redshift, potresti notare che la derivazione degli asset non è collegata a un set di dati upstream. Questo argomento spiega gli scenari e alcuni approcci per mitigare i problemi. Per ulteriori informazioni sulla discendenza, vedere. [Linea dei dati in Amazon DataZone](datazone-data-lineage.md)

### SourceIdentifier sul nodo di lignaggio
<a name="troubleshooting-lineage-source-identifier"></a>

L'`sourceIdentifier`attributo in un nodo di derivazione rappresenta gli eventi che si verificano su un set di dati. Per ulteriori informazioni, vedete [Attributi chiave nei nodi di derivazione](https://docs.aws.amazon.com/datazone/latest/userguide/datazone-data-lineage.html#datazone-data-lineage-key-attributes).

Il nodo di derivazione rappresenta tutti gli eventi che si verificano nel set di dati o nel processo corrispondente. Il nodo di derivazione contiene un attributo «sourceIdentifier» che contiene l'identificatore del set di dati/job corrispondente. Poiché supportiamo gli eventi open-lineage, per impostazione predefinita il `sourceIdentifier` valore viene compilato come combinazione di «namespace» e «name» per un set di dati, un processo e le esecuzioni di lavoro.

Per AWS risorse come AWS Glue Amazon Redshift, `sourceIdentifier` sarebbero disponibili la tabella AWS Glue ARN e la tabella Redshift ARNs da cui DataZone Amazon costruirà l'evento run-event e altri dettagli come segue:

**Nota**  
 In AWS, l'ARN contiene informazioni come AccountID, regione, database e tabella per ogni risorsa.
+ OpenLineage l'evento per questi set di dati contiene il nome del database e della tabella.
+ La regione viene acquisita nell'aspetto «proprietà dell'ambiente» di una corsa. Se non è presente, il sistema utilizza la regione indicata nelle credenziali del chiamante.
+ AccountId viene ricavata dalle credenziali del chiamante.

**SourceIdentifier sulle risorse interne DataZone**  
`AssetCommonDetailForm`ha un attributo chiamato «sourceIdentifier» che rappresenta l'identificatore del set di dati rappresentato dall'asset. Affinché i nodi di derivazione degli asset siano collegati a un set di dati upstream, l'attributo deve essere compilato con il valore corrispondente a quello del nodo del set di dati. `sourceIdentifier` Se le risorse vengono importate da datasource, il flusso di lavoro viene compilato automaticamente `sourceIdentifier` come tabella AWS Glue ARN/Redshift ARN, mentre altre risorse (incluse le risorse personalizzate) create tramite l'`CreateAsset`API dovrebbero avere quel valore compilato dal chiamante.

### In che modo Amazon DataZone costruisce il SourceIdentifier a partire dall'evento? OpenLineage
<a name="troubleshooting-lineage"></a>

Per AWS Glue gli asset Redshift, `sourceIdentifier` è costruito a partire da Glue e Redshift. ARNs Ecco come Amazon lo DataZone costruisce:

#### AWS Glue ARN
<a name="troubleshooting-lineage-constructing-glue-arn"></a>

L'obiettivo è costruire un OpenLineage evento in cui il nodo di derivazione di output sia: `sourceIdentifier`

```
arn:aws:glue:us-east-1:123456789012:table/testlfdb/testlftb-1
```

Per determinare se una corsa utilizza dati provenienti da AWS Glue, cercate la presenza di determinate parole chiave nel `environment-properties` facet. In particolare, se uno di questi campi designati è presente, il sistema presume che `RunEvent` provenga da. AWS Glue
+ GLUE\_VERSION
+ GLUE\_COMMAND\_CRITERIA
+ VERSIONE GLUE\_PYTHON

```
"run": {
   "runId":"4e3da9e8-6228-4679-b0a2-fa916119fthr",
   "facets":{
      "environment-properties":{
         "_producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/spark",
         "_schemaURL":"https://openlineage.io/spec/2-0-2/OpenLineage.json#/$defs/RunFacet",
         "environment-properties":{
            "GLUE_VERSION":"3.0",
            "GLUE_COMMAND_CRITERIA":"glueetl",
            "GLUE_PYTHON_VERSION":"3"
         }
      }
   }
```

Per AWS Glue eseguire, è possibile utilizzare il nome del `symlinks` facet per ottenere il nome del database e della tabella, che possono essere utilizzati per costruire l'ARN.

È necessario assicurarsi che il nome sia: `databaseName.tableName`

```
"symlinks": {
   "_producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/spark",
   "_schemaURL":"https://openlineage.io/spec/facets/1-0-0/SymlinksDatasetFacet.json#/$defs/SymlinksDatasetFacet",
   "identifiers":[
      {
         "namespace":"s3://object-path",
         "name":"testlfdb.testlftb-1",
         "type":"TABLE"
      }
   ]
}
```

Esempio di evento COMPLETO:

```
{
   "eventTime":"2024-07-01T12:00:00.000000Z",
   "producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/glue",
   "schemaURL":"https://openlineage.io/spec/2-0-2/OpenLineage.json#/$defs/RunEvent",
   "eventType":"COMPLETE",
   "run": {
      "runId":"4e3da9e8-6228-4679-b0a2-fa916119fthr",
      "facets":{
         "environment-properties":{
            "_producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/spark",
            "_schemaURL":"https://openlineage.io/spec/2-0-2/OpenLineage.json#/$defs/RunFacet",
            "environment-properties":{
               "GLUE_VERSION":"3.0",
               "GLUE_COMMAND_CRITERIA":"glueetl",
               "GLUE_PYTHON_VERSION":"3"
            }
         }
      }
   },
   "job":{
      "namespace":"namespace",
      "name":"job_name",
      "facets":{
         "jobType":{
            "_producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/glue",
            "_schemaURL":"https://openlineage.io/spec/facets/2-0-2/JobTypeJobFacet.json#/$defs/JobTypeJobFacet",
            "processingType":"BATCH",
            "integration":"glue",
            "jobType":"JOB"
         }
      }
   },
   "inputs":[
      {
         "namespace":"namespace",
         "name":"input_name"
      }
   ],
   "outputs":[
      {
         "namespace":"namespace.output",
         "name":"output_name",
         "facets":{
            "symlinks":{
               "_producer":"https://github.com/OpenLineage/OpenLineage/tree/1.9.1/integration/spark",
               "_schemaURL":"https://openlineage.io/spec/facets/1-0-0/SymlinksDatasetFacet.json#/$defs/SymlinksDatasetFacet",
               "identifiers":[
                  {
                     "namespace":"s3://object-path",
                     "name":"testlfdb.testlftb-1",
                     "type":"TABLE"
                  }
               ]
            }
         }
      }
   ]
}
```

In base all'`OpenLineage`evento inviato, il nodo `sourceIdentifier` di derivazione di output sarà:

```
arn:aws:glue:us-east-1:123456789012:table/testlfdb/testlftb-1
```

Il nodo di derivazione di uscita sarà collegato al nodo di derivazione di una risorsa in cui quello della risorsa è: `sourceIdentifier`

```
arn:aws:glue:us-east-1:123456789012:table/testlfdb/testlftb-1
```

![La schermata mostra l'identificatore di origine di una risorsa.](http://docs.aws.amazon.com/it_it/datazone/latest/userguide/images/troubleshoot-lineage1.png)


![La schermata mostra l'identificatore di origine di una risorsa.](http://docs.aws.amazon.com/it_it/datazone/latest/userguide/images/troubleshoot-lineage2.png)


#### ARN Amazon Redshift
<a name="troubleshooting-lineage-constructing-redshift-arn"></a>

L'obiettivo è creare un OpenLineage evento in cui il nodo di derivazione di output sia: `sourceIdentifier`

```
arn:aws:redshift:us-east-1:123456789012:table/workgroup-20240715/tpcds_data/public/dws_tpcds_7
```

Il sistema determina se un input o un output è memorizzato in Redshift in base allo spazio dei nomi. In particolare, se lo spazio dei nomi inizia con redshift://o contiene le stringhe `redshift-serverless.amazonaws.com` o`redshift.amazonaws.com`, è una risorsa Redshift.

```
"outputs": [
    {
        "namespace":"redshift://workgroup-20240715.123456789012.us-east-1.redshift.amazonaws.com:5439",
        "name":"tpcds_data.public.dws_tpcds_7"
    }
]
```

Nota che lo spazio dei nomi deve avere il seguente formato:

```
provider://{cluster_identifier}.{region_name}:{port}
```

Per `redshift-serverless`:

```
"outputs": [
    {
        "namespace":"redshift://workgroup-20240715.123456789012.us-east-1.redshift-serverless.amazonaws.com:5439",
        "name":"tpcds_data.public.dws_tpcds_7"
    }
]
```

I risultati sono i seguenti `sourceIdentifier`

```
arn:aws:redshift-serverless:us-east-1:123456789012:table/workgroup-20240715/tpcds_data/public/dws_tpcds_7
```

In base all' OpenLineage evento inviato, il nodo `sourceIdentifier` di derivazione da mappare su un nodo di derivazione a valle (ovvero un output dell'evento) è:

```
arn:aws:redshift-serverless:us-e:us-east-1:123456789012:table/workgroup-20240715/tpcds_data/public/dws_tpcds_7
```

Questa è la mappatura che consente di visualizzare la derivazione di una risorsa nel catalogo.

### Approccio alternativo
<a name="troubleshooting-lineage-alternate-approach"></a>

Quando nessuna delle condizioni precedenti è soddisfatta, il sistema utilizza il **namespace**/**name per costruire:** `sourceIdentifier`

```
"inputs": [
  {
     "namespace":"arn:aws:redshift:us-east-1:123456789012:table",
     "name":"workgroup-20240715/tpcds_data/public/dws_tpcds_7"
  }
],
"outputs": [
  {
     "namespace":"arn:aws:glue:us-east-1:123456789012:table",
     "name":"testlfdb/testlftb-1"
  }
]
```

### Risoluzione di una mancanza di upstream per il nodo Asset Lineage
<a name="troubleshooting-lineage-upstream"></a>

Se non vedi il codice a monte del nodo di derivazione degli asset, puoi fare quanto segue per risolvere il motivo per cui non è collegato al set di dati:

1. Invoca fornendo `GetAsset` e: `domainId` `assetId`

   ```
   aws datazone get-asset --domain-identifier <domain-id> --identifier <asset-id>
   ```

   La risposta appare come segue:

   ```
   {
       .....
       "formsOutput": [
           ..... 
           {
               "content": "{\"sourceIdentifier\":\"arn:aws:glue:eu-west-1:123456789012:table/testlfdb/testlftb-1\"}",
               "formName": "AssetCommonDetailsForm",
               "typeName": "amazon.datazone.AssetCommonDetailsFormType",
               "typeRevision": "6"
           },
           .....
       ],
       "id": "<asset-id>",
       ....
   }
   ```

1. `GetLineageNode`Invoca per ottenere il nodo `sourceIdentifier` di derivazione del set di dati. Poiché non è possibile ottenere direttamente il nodo di derivazione per il nodo del set di dati corrispondente, è possibile iniziare dall'esecuzione del lavoro: `GetLineageNode`

   ```
   aws datazone get-lineage-node --domain-identifier <domain-id> --identifier <job_namespace>.<job_name>/<run_id>
   
   if you are using the getting started scripts, job name and run ID are printed in the console
   and namespace is "default". Otherwise you can get these values from run event content.
   ```

   La risposta di esempio è la seguente:

   ```
   {
       .....
       "downstreamNodes": [
           {
               "eventTimestamp": "2024-07-24T18:08:55+08:00",
               "id": "afymge5k4v0euf"
           }
       ],
       "formsOutput": [
           <some forms corresponding to run and job>
       ],
       "id": "<system generated node-id for run>",
       "sourceIdentifier": "default.redshift.create/2f41298b-1ee7-3302-a14b-09addffa7580",
       "typeName": "amazon.datazone.JobRunLineageNodeType",
       ....
       "upstreamNodes": [
           {
               "eventTimestamp": "2024-07-24T18:08:55+08:00",
               "id": "6wf2z27c8hghev"
           },
           {
               "eventTimestamp": "2024-07-24T18:08:55+08:00",
               "id": "4tjbcsnre6banb"
           }
       ]
   }
   ```

1. Invocate `GetLineageNode` nuovamente inserendo l'identificatore del downstream/upstream nodo (che ritenete debba essere collegato al nodo dell'asset) poiché questi corrispondono al set di dati:

   Comando di esempio che utilizza la risposta di esempio precedente:

   ```
   aws datazone get-lineage-node --domain-identifier <domain-id> --identifier afymge5k4v0euf
   ```

   Ciò restituisce i dettagli del nodo di derivazione corrispondenti al set di dati: afymge5k4v0euf

   ```
   {
       .....
       "domainId": "dzd_cklzc5s2jcr7on",
       "downstreamNodes": [],
       "eventTimestamp": "2024-07-24T18:08:55+08:00",
       "formsOutput": [
           .....
       ],
       "id": "afymge5k4v0euf",
       "sourceIdentifier": "arn:aws:redshift:us-east-1:123456789012:table/workgroup-20240715/tpcds_data/public/dws_tpcds_7",
       "typeName": "amazon.datazone.DatasetLineageNodeType",
       "typeRevision": "1",
       ....
       "upstreamNodes": [
           ...
       ]
   }
   ```

1. Confronta il nodo di questo set di dati e la risposta di. `sourceIdentifier` `GetAsset` Se non sono collegati, non corrisponderanno e quindi non saranno visibili nell'interfaccia utente di Lineage.

**Scenari e mitigazioni non corrispondenti**  
Di seguito sono riportati gli scenari comunemente noti in cui questi non corrispondono e le possibili mitigazioni:

**Causa principale**: le tabelle sono presenti in un account diverso da quello dell'account di DataZone dominio Amazon.

**Attenuazione**: è possibile richiamare l'`PostLineageEvent`operazione da un account associato. Poiché l'`accountId`ARN viene scelto tra le credenziali del chiamante, è possibile assumere il ruolo dell'account contenente le tabelle durante l'esecuzione dello script introduttivo o l'invocazione. `PostLineageEvent` Ciò contribuirà a costruire ARNs correttamente i nodi dell'asset e a collegarsi con gli asset.

**Causa principale**: l'ARN per Redshift table/views contiene Redshift/Redshift-Serverless in base allo spazio dei nomi e agli attributi dei nomi delle informazioni sul set di dati corrispondenti nell'evento run. OpenLineage 

**Attenuazione**: poiché non esiste un modo deterministico per sapere se il nome dato appartiene al cluster o al gruppo di lavoro, utilizziamo la seguente euristica:
+ Se il «nome» corrispondente al set di dati contiene "`redshift-serverless.amazonaws.com`«, utilizziamo redshift-serverless come parte dell'ARN, altrimenti l'impostazione predefinita è «redshift».
+ Quanto sopra significa che gli alias sui nomi dei gruppi di lavoro non funzioneranno.

**Causa principale**: i set di dati upstream non sono collegati correttamente per le risorse personalizzate.

**Attenuazione** <namespace><name>: assicurati di compilare il codice `sourceIdentifier` sulla risorsa invocando`CreateAsset`/`CreateAssetRevision`che corrisponde al nodo del set `sourceIdentifier` di dati (che sarebbe/per i nodi personalizzati).