Importazione ed esportazione di dati DICOM tramite Cloud Storage

In questa pagina viene spiegato come esportare le istanze DICOM da Cloud Storage e come importarvi oggetti DICOM. Un'istanza DICOM è generalmente un'immagine, ma può un altro tipo di dati permanenti, ad esempio i report strutturati. Un oggetto DICOM Cloud Storage è un'istanza DICOM che risiede di archiviazione ideale in Cloud Storage. Per saperne di più, consulta Cloud Storage.

Impostazione delle autorizzazioni Cloud Storage

Prima di esportare e importare i dati DICOM da e verso Cloud Storage, devi concedere autorizzazioni aggiuntive all'interfaccia Agente di servizio Healthcare account di servizio. Per ulteriori informazioni, vedi Autorizzazioni Cloud Storage per gli archivi DICOM.

Importazione degli oggetti DICOM

Per importare diversi file di istanza DICOM in un archivio DICOM, puoi utilizza uno dei seguenti metodi:

Gli esempi riportati di seguito mostrano come importare gli oggetti DICOM da un bucket Cloud Storage.

Console

Per importare oggetti DICOM da un bucket Cloud Storage, completa i seguenti passaggi:

  1. Nella console Google Cloud, vai alla pagina Set di dati.
    Vai a Set di dati
  2. Fai clic sul set di dati che contiene l'archivio DICOM a cui sei importando gli oggetti DICOM.
  3. Nell'elenco di datastore, scegli Importa dall'elenco Azioni per l'archivio DICOM.

    Viene visualizzata la pagina Importa nell'archivio DICOM.
  4. Nell'elenco Progetto, seleziona un progetto Cloud Storage.
  5. Nell'elenco Località, seleziona un bucket Cloud Storage.
  6. Per impostare una posizione specifica per l'importazione dei file:
    1. Espandi Opzioni avanzate.
    2. Seleziona Override del percorso di Cloud Storage.
    3. Per impostare un'origine specifica per l'importazione dei file, definisci il percorso utilizzando le seguenti variabili nella casella di testo Posizione:
      • *: trova caratteri non separatori.
      • **: trova caratteri, inclusi i separatori. Può essere utilizzata con un'estensione di nome file per trovare corrispondenze di tutti i file di sono dello stesso tipo.
      • ?: corrisponde a 1 carattere.
  7. Fai clic su Importa per importare gli oggetti DICOM dall'origine definita.
  8. Per monitorare lo stato dell'operazione, fai clic sulla scheda Operazioni. Dopo l'operazione vengono visualizzate le seguenti indicazioni:
    • La sezione Stato dell'operazione a lunga esecuzione ha un segno di spunta verde sotto la Intestazione OK.
    • La sezione Panoramica ha un segno di spunta verde e un indicatore OK. nella stessa riga dell'ID operazione.
    In caso di errori, fai clic su Azioni e poi su Visualizza dettagli in Cloud Logging,

gcloud

Per importare gli oggetti DICOM da un bucket Cloud Storage, utilizza gcloud healthcare dicom-stores import gcs . Specifica il nome del set di dati padre, il nome dell'archivio DICOM, e la posizione dell'oggetto in un bucket Cloud Storage.

  • La posizione dei file nel bucket è arbitraria e non deve necessariamente corrispondere esattamente al formato specificato nel seguente esempio.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, puoi utilizzare caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con 0 o più caratteri non separatori. Ad esempio: gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm ed Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare una corrispondenza con 0 o più caratteri (inclusi i separatori). Deve essere utilizzato in alla fine di un percorso e senza altri caratteri jolly nel percorso. Si possono usare anche con un'estensione di nome file (come .dcm), che importa tutti i file con l'estensione del nome file nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm del nome file in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per trovare una corrispondenza con 1 carattere. Ad esempio: gs://BUCKET/DIRECTORY/Example?.dcm corrispondenze Esempio1.dcm ma non corrisponde a Esempio.dcm o Esempio01.dcm.

L'esempio seguente mostra come importare gli oggetti DICOM da un nel bucket Cloud Storage.

gcloud healthcare dicom-stores import gcs DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --gcs-uri=gs://BUCKET/DIRECTORY/DICOM_INSTANCE.dcm

La riga di comando mostra l'ID operazione:

name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

gcloud healthcare operations describe OPERATION_ID \
  --location=LOCATION \
  --dataset=DATASET_ID

Al termine del comando, la risposta include done: true.

done: true
metadata:
'@type': type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata
apiMethodName: google.cloud.healthcare.v1.dicom.DicomService.ImportDicomData
counter:
  success: SUCCESSFUL_INSTANCES
  failure: FAILED_INSTANCES
createTime: "CREATE_TIME"
endTime: "END_TIME"
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID
response:
'@type': "..."

API

Per importare gli oggetti DICOM da un bucket Cloud Storage, utilizza il metodo projects.locations.datasets.dicomStores.import.

  • La posizione dei file all'interno del bucket può variare e non è necessario corrispondano al formato specificato nei seguenti esempi.
  • Quando specifichi la posizione degli oggetti DICOM in Cloud Storage, utilizzare caratteri jolly per importare più file da una o più directory. Sono supportati i seguenti caratteri jolly:
    • Utilizza * per trovare una corrispondenza con 0 o più caratteri non separatori. Ad esempio: gs://BUCKET/DIRECTORY/Example*.dcm corrisponde a Example.dcm ed Example22.dcm in DIRECTORY.
    • Utilizza ** per trovare una corrispondenza con 0 o più caratteri (inclusi i separatori). Deve essere utilizzato in alla fine di un percorso e senza altri caratteri jolly nel percorso. Si possono usare anche con un'estensione di nome file (come .dcm), che importa tutti i file con l'estensione del nome file nella directory specificata e nelle relative sottodirectory. Ad esempio, gs://BUCKET/DIRECTORY/**.dcm importa tutti i file con l'estensione .dcm del nome file in DIRECTORY e nelle relative sottodirectory.
    • Usa ? per trovare una corrispondenza con 1 carattere. Ad esempio: gs://BUCKET/DIRECTORY/Example?.dcm corrispondenze Esempio1.dcm ma non corrisponde a Esempio.dcm o Esempio01.dcm.

REST

  1. Importa l'oggetto DICOM.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID datastore DICOM
    • BUCKET/PATH/TO/FILE: il percorso dell'oggetto DICOM in Cloud Storage

    Corpo JSON della richiesta: 

    {
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    cat > request.json << 'EOF'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}
EOF

    Quindi, esegui questo comando per inviare la richiesta REST: 

    curl -X POST \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         -H "Content-Type: application/json" \
         -d @request.json \
         "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import"

    PowerShell

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    @'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

    Quindi, esegui il seguente comando per inviare la richiesta REST: 

    $cred = gcloud auth print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    Invoke-WebRequest `
        -Method POST `
        -Headers $headers `
        -ContentType: "application/json" `
        -InFile request.json `
        -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import" | Select-Object -Expand Content
    L'output è il seguente. La risposta contiene un identificatore per un operazione a lunga esecuzione. Le operazioni a lunga esecuzione vengono restituite quando le chiamate ai metodi possono richiedere un per il completamento. Prendi nota del valore di OPERATION_ID. È necessario questo valore nel passaggio successivo.

  2. Visualizza lo stato dell'operazione a lunga esecuzione.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • OPERATION_ID: l'ID restituito dall'operazione a lunga esecuzione

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Esegui questo comando: 

    curl -X GET \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"

    PowerShell

    Esegui questo comando: 

    $cred = gcloud auth print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    Invoke-WebRequest `
        -Method GET `
        -Headers $headers `
        -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content
    Se l'operazione a lunga esecuzione è ancora in esecuzione, il server restituisce una risposta con il numero di istanze DICOM in attesa di importazione. Al termine dell'operazione, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

Go

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// importDICOMInstance imports DICOM objects from GCS.
func importDICOMInstance(w io.Writer, projectID, location, datasetID, dicomStoreID, contentURI string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %w", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	req := &healthcare.ImportDicomDataRequest{
		GcsSource: &healthcare.GoogleCloudHealthcareV1DicomGcsSource{
			Uri: contentURI,
		},
	}
	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

	lro, err := storesService.Import(name, req).Do()
	if err != nil {
		return fmt.Errorf("Import: %w", err)
	}

	fmt.Fprintf(w, "Import to DICOM store started. Operation: %q\n", lro.Name)
	return nil
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.GoogleCloudHealthcareV1DicomGcsSource;
import com.google.api.services.healthcare.v1.model.ImportDicomDataRequest;
import com.google.api.services.healthcare.v1.model.Operation;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreImport {
  private static final String DICOM_NAME = "projects/%s/locations/%s/datasets/%s/dicomStores/%s";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void dicomStoreImport(String dicomStoreName, String gcsUri) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");
    // String gcsUri = "gs://your-bucket-id/path/to/destination/dir"

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Configure where the store should be imported from.
    GoogleCloudHealthcareV1DicomGcsSource gcsSource =
        new GoogleCloudHealthcareV1DicomGcsSource().setUri(gcsUri);
    ImportDicomDataRequest importRequest = new ImportDicomDataRequest().setGcsSource(gcsSource);

    // Create request and configure any parameters.
    DicomStores.CloudHealthcareImport request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .healthcareImport(dicomStoreName, importRequest);

    // Execute the request, wait for the operation to complete, and process the results.
    try {
      Operation operation = request.execute();
      while (operation.getDone() == null || !operation.getDone()) {
        // Update the status of the operation with another request.
        Thread.sleep(500); // Pause for 500ms between requests.
        operation =
            client
                .projects()
                .locations()
                .datasets()
                .operations()
                .get(operation.getName())
                .execute();
      }
      System.out.println("DICOM store import complete." + operation.getResponse());
    } catch (Exception ex) {
      System.out.printf("Error during request execution: %s", ex.toString());
      ex.printStackTrace(System.out);
    }
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});
const sleep = ms => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

const importDicomInstance = async () => {
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  // const gcsUri = 'my-bucket/my-directory/*.dcm'
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {
    name,
    resource: {
      // The location of the DICOM instances in Cloud Storage
      gcsSource: {
        uri: `gs://${gcsUri}`,
      },
    },
  };

  const operation =
    await healthcare.projects.locations.datasets.dicomStores.import(request);
  const operationName = operation.data.name;

  const operationRequest = {name: operationName};

  // Wait fifteen seconds for the LRO to finish.
  await sleep(15000);

  // Check the LRO's status
  const operationStatus =
    await healthcare.projects.locations.datasets.operations.get(
      operationRequest
    );

  const {data} = operationStatus;

  if (data.error === undefined) {
    console.log('Successfully imported DICOM instances');
  } else {
    console.log('Encountered errors. Sample error:');
    console.log(
      'Resource on which error occured:',
      data.error.details[0]['sampleErrors'][0]['resource']
    );
    console.log(
      'Error code:',
      data.error.details[0]['sampleErrors'][0]['error']['code']
    );
    console.log(
      'Error message:',
      data.error.details[0]['sampleErrors'][0]['error']['message']
    );
  }
};

importDicomInstance();

Python

def import_dicom_instance(
    project_id, location, dataset_id, dicom_store_id, content_uri
):
    """Imports data into the DICOM store by copying it from the specified
    source.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/dicom
    before running the sample."""
    # Imports the Google API Discovery Service.
    from googleapiclient import discovery

    api_version = "v1"
    service_name = "healthcare"
    # Returns an authorized API client by discovering the Healthcare API
    # and using GOOGLE_APPLICATION_CREDENTIALS environment variable.
    client = discovery.build(service_name, api_version)

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the DICOM store's parent dataset ID
    # dicom_store_id = 'my-dicom-store'  # replace with the DICOM store's ID
    # content_uri = 'my-bucket/*.dcm'  # replace with a Cloud Storage bucket and DCM files
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, location, dataset_id
    )
    dicom_store_name = f"{dicom_store_parent}/dicomStores/{dicom_store_id}"

    body = {"gcsSource": {"uri": f"gs://{content_uri}"}}

    # Escape "import()" method keyword because "import"
    # is a reserved keyword in Python
    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .import_(name=dicom_store_name, body=body)
    )

    response = request.execute()
    print(f"Imported DICOM instance: {content_uri}")

    return response

Per recuperare una singola istanza o studio da un archivio DICOM, recuperare dati DICOM utilizzando il pulsante Recupera transazione Servizio web RESTful implementato nell'API Cloud Healthcare.

Specifica una classe di archiviazione per importare gli oggetti DICOM (anteprima)

Per impostazione predefinita, il metodo projects.locations.datasets.dicomStores.import importa a un archivio DICOM con una classe di archiviazione standard. Puoi impostare di archiviazione quando si importano gli oggetti DICOM da Cloud Storage. Per ulteriori informazioni, vedi Modifica la classe di archiviazione DICOM.

I seguenti esempi mostrano come specificare la classe di archiviazione durante l'importazione Oggetti DICOM da Cloud Storage.

REST

Utilizza la projects.locations.datasets.dicomStores.import .

  1. Importa l'oggetto DICOM.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • DICOM_STORE_ID: l'ID datastore DICOM
    • BUCKET/PATH/TO/FILE: il percorso dell'oggetto DICOM in Cloud Storage
    • STORAGE_CLASS: la classe di archiviazione per l'oggetto DICOM nell'archivio DICOM da STANDARD, NEARLINE, COLDLINE e ARCHIVE

    Corpo JSON della richiesta: 

    {
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    cat > request.json << 'EOF'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}
EOF

    Quindi, esegui questo comando per inviare la richiesta REST: 

    curl -X POST \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         -H "Content-Type: application/json" \
         -d @request.json \
         "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import"

    PowerShell

    Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente: 

    @'
{
  "gcsSource": {
    "uri": "gs://BUCKET/PATH/TO/FILE.dcm"
  },
  "blob_storage_settings": {
    "blob_storage_class": "STORAGE_CLASS"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

    Quindi, esegui il seguente comando per inviare la richiesta REST: 

    $cred = gcloud auth print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    Invoke-WebRequest `
        -Method POST `
        -Headers $headers `
        -ContentType: "application/json" `
        -InFile request.json `
        -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:import" | Select-Object -Expand Content
    L'output è il seguente. La risposta contiene un identificatore per un operazione a lunga esecuzione. Le operazioni a lunga esecuzione vengono restituite quando le chiamate ai metodi possono richiedere un per il completamento. Prendi nota del valore di OPERATION_ID. È necessario questo valore nel passaggio successivo.

  2. Visualizza lo stato dell'operazione a lunga esecuzione.

    Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud
    • LOCATION: la posizione del set di dati
    • DATASET_ID: set di dati padre dell'archivio DICOM
    • OPERATION_ID: l'ID restituito dall'operazione a lunga esecuzione

    Per inviare la richiesta, scegli una delle seguenti opzioni:

    curl

    Esegui questo comando: 

    curl -X GET \
         -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"

    PowerShell

    Esegui questo comando: 

    $cred = gcloud auth print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    Invoke-WebRequest `
        -Method GET `
        -Headers $headers `
        -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content
    Se l'operazione a lunga esecuzione è ancora in esecuzione, il server restituisce una risposta con il numero di istanze DICOM in attesa di importazione. Al termine dell'operazione LRO, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

Risoluzione dei problemi delle richieste di importazione DICOM

Se si verificano errori durante una richiesta di importazione DICOM, gli errori vengono registrati Cloud Logging. Per ulteriori informazioni, vedi Visualizzazione dei log degli errori in Cloud Logging.

Esportazione delle istanze DICOM

Gli esempi riportati di seguito mostrano come esportare le istanze DICOM in un bucket Cloud Storage. Questa operazione prevede l'esportazione di tutte le istanze nell'archivio DICOM.

Console

Per esportare le istanze DICOM in Cloud Storage, completa i seguenti passaggi:

  1. Nella console Google Cloud, vai alla pagina Set di dati.
    Vai a Set di dati
  2. Fai clic sul set di dati che contiene l'archivio DICOM da cui esportando le istanze DICOM.
  3. Nell'elenco dei datastore, scegli Esporta dal menu a discesa Azioni. per l'archivio DICOM.
  4. Nella pagina Esporta archivio DICOM che viene visualizzata, seleziona Bucket Google Cloud Storage.
  5. Nell'elenco Progetto, seleziona un progetto Cloud Storage.
  6. Nell'elenco Località, seleziona un bucket Cloud Storage.
  7. In Impostazioni di esportazione DICOM, seleziona il tipo di file utilizzato per esportare le istanze DICOM. Sono disponibili i seguenti tipi:
    • File DICOM (.dcm)
    • octet-stream
    • Immagine (.jpg, .png)
  8. Per definire una sintassi di trasferimento aggiuntiva, scegli la sintassi dall'elenco Sintassi di trasferimento.
  9. Fai clic su Esporta per esportare le istanze DICOM nella posizione definita. in Cloud Storage.
  10. Per monitorare lo stato dell'operazione, fai clic sulla scheda Operazioni. Dopo l'operazione vengono visualizzate le seguenti indicazioni:
    • La sezione Stato dell'operazione a lunga esecuzione ha un segno di spunta verde sotto la Intestazione OK.
    • La sezione Panoramica ha un segno di spunta verde e un indicatore OK. nella stessa riga dell'ID operazione.
    In caso di errori, fai clic su Azioni e poi su Visualizza dettagli in Cloud Logging,

gcloud

Per esportare le istanze DICOM in un bucket Cloud Storage, utilizza gcloud healthcare dicom-stores export gcs .

  • Indica il nome del set di dati padre, il nome dell'archivio DICOM e nel bucket Cloud Storage di destinazione.
  • Scrivi in un bucket o in una directory Cloud Storage, anziché in un oggetto, poiché l'API Cloud Healthcare crea un file .dcm per ogni oggetto.
  • Se il comando specifica una directory che non esiste, la directory viene creato.

L'esempio seguente mostra il comando gcloud healthcare dicom-stores export gcs.

gcloud healthcare dicom-stores export gcs DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --gcs-uri-prefix=gs://BUCKET/DIRECTORY

La riga di comando visualizza l'ID operazione:

name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

gcloud healthcare operations describe OPERATION_ID \
  --location=LOCATION \
  --dataset=DATASET_ID

Al termine del comando, la risposta include done: true.

done: true
metadata:
'@type': type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata
apiMethodName: google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData
counter:
  success: SUCCESSFUL_INSTANCES
  failure: FAILED_INSTANCES
createTime: "CREATE_TIME"
endTime: "END_TIME"
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID
response:
'@type': "..."

API

Per esportare le istanze DICOM in un bucket Cloud Storage, utilizza projects.locations.datasets.dicomStores.export .

  • di scrivere in un bucket o in una directory Cloud Storage, anziché in un oggetto, perché l'API Cloud Healthcare crea un file .dcm per ogni oggetto DICOM.
  • Se il comando specifica una directory che non esiste, la directory viene creato.

curl

Per esportare le istanze DICOM, effettua una richiesta POST e fornisci le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione

L'esempio seguente mostra una richiesta POST che utilizza curl.

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'gcsDestination': {
        'uriPrefix': 'gs://BUCKET/DIRECTORY'
      }
    }" "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export"

Se la richiesta riesce, il server restituisce la risposta in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La risposta contiene il nome di un'operazione. Per monitorare lo stato dell'operazione, utilizza il metodo Operation get:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"

Se la richiesta riesce, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/query/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    }
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Per esportare le istanze DICOM, effettua una richiesta POST e fornisci le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione

L'esempio seguente mostra una richiesta POST mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
    'gcsDestination': {
      'uriPrefix': 'gs://BUCKET/DIRECTORY'
    }
  }" `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export" | Select-Object -Expand Content

Se la richiesta riesce, il server restituisce la risposta in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La risposta contiene il nome di un'operazione. Per monitorare lo stato dell'operazione, utilizza la Metodo dell'operazione get:

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content

Se la richiesta riesce, il server restituisce una risposta con lo stato dell'operazione in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME",
    "logsUrl": "https://console.cloud.google.com/logs/query/CLOUD_LOGGING_URL",
    "counter":{
       "success": SUCCESSFUL_INSTANCES
       "failure": FAILED_INSTANCES
    },
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

Go

import (
	"context"
	"fmt"
	"io"

	healthcare "google.golang.org/api/healthcare/v1"
)

// exportDICOMInstance exports DICOM objects to GCS.
func exportDICOMInstance(w io.Writer, projectID, location, datasetID, dicomStoreID, destination string) error {
	ctx := context.Background()

	healthcareService, err := healthcare.NewService(ctx)
	if err != nil {
		return fmt.Errorf("healthcare.NewService: %w", err)
	}

	storesService := healthcareService.Projects.Locations.Datasets.DicomStores

	req := &healthcare.ExportDicomDataRequest{
		GcsDestination: &healthcare.GoogleCloudHealthcareV1DicomGcsDestination{
			UriPrefix: destination, // "gs://my-bucket/path/to/prefix/"
		},
	}
	name := fmt.Sprintf("projects/%s/locations/%s/datasets/%s/dicomStores/%s", projectID, location, datasetID, dicomStoreID)

	lro, err := storesService.Export(name, req).Do()
	if err != nil {
		return fmt.Errorf("Export: %w", err)
	}

	fmt.Fprintf(w, "Export to DICOM store started. Operation: %q\n", lro.Name)
	return nil
}

Java

import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.healthcare.v1.CloudHealthcare;
import com.google.api.services.healthcare.v1.CloudHealthcare.Projects.Locations.Datasets.DicomStores;
import com.google.api.services.healthcare.v1.CloudHealthcareScopes;
import com.google.api.services.healthcare.v1.model.ExportDicomDataRequest;
import com.google.api.services.healthcare.v1.model.GoogleCloudHealthcareV1DicomGcsDestination;
import com.google.api.services.healthcare.v1.model.Operation;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Collections;

public class DicomStoreExport {
  private static final String DICOM_NAME = "projects/%s/locations/%s/datasets/%s/dicomStores/%s";
  private static final JsonFactory JSON_FACTORY = new GsonFactory();
  private static final NetHttpTransport HTTP_TRANSPORT = new NetHttpTransport();

  public static void dicomStoreExport(String dicomStoreName, String gcsUri) throws IOException {
    // String dicomStoreName =
    //    String.format(
    //        DICOM_NAME, "your-project-id", "your-region-id", "your-dataset-id", "your-dicom-id");
    // String gcsUri = "gs://your-bucket-id/path/to/destination/dir"

    // Initialize the client, which will be used to interact with the service.
    CloudHealthcare client = createClient();

    // Configure where the store will be exported too.
    GoogleCloudHealthcareV1DicomGcsDestination gcsDestination =
        new GoogleCloudHealthcareV1DicomGcsDestination().setUriPrefix(gcsUri);
    ExportDicomDataRequest exportRequest =
        new ExportDicomDataRequest().setGcsDestination(gcsDestination);

    // Create request and configure any parameters.
    DicomStores.Export request =
        client
            .projects()
            .locations()
            .datasets()
            .dicomStores()
            .export(dicomStoreName, exportRequest);

    // Execute the request, wait for the operation to complete, and process the results.
    try {
      Operation operation = request.execute();
      while (operation.getDone() == null || !operation.getDone()) {
        // Update the status of the operation with another request.
        Thread.sleep(500); // Pause for 500ms between requests.
        operation =
            client
                .projects()
                .locations()
                .datasets()
                .operations()
                .get(operation.getName())
                .execute();
      }
      System.out.println("DICOM store export complete." + operation.getResponse());
    } catch (Exception ex) {
      System.out.printf("Error during request execution: %s", ex.toString());
      ex.printStackTrace(System.out);
    }
  }

  private static CloudHealthcare createClient() throws IOException {
    // Use Application Default Credentials (ADC) to authenticate the requests
    // For more information see https://cloud.google.com/docs/authentication/production
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(CloudHealthcareScopes.CLOUD_PLATFORM));

    // Create a HttpRequestInitializer, which will provide a baseline configuration to all requests.
    HttpRequestInitializer requestInitializer =
        request -> {
          new HttpCredentialsAdapter(credential).initialize(request);
          request.setConnectTimeout(60000); // 1 minute connect timeout
          request.setReadTimeout(60000); // 1 minute read timeout
        };

    // Build the client for interacting with the service.
    return new CloudHealthcare.Builder(HTTP_TRANSPORT, JSON_FACTORY, requestInitializer)
        .setApplicationName("your-application-name")
        .build();
  }
}

Node.js

const google = require('@googleapis/healthcare');
const healthcare = google.healthcare({
  version: 'v1',
  auth: new google.auth.GoogleAuth({
    scopes: ['https://www.googleapis.com/auth/cloud-platform'],
  }),
});

const exportDicomInstanceGcs = async () => {
  // TODO(developer): uncomment these lines before running the sample
  // const cloudRegion = 'us-central1';
  // const projectId = 'adjective-noun-123';
  // const datasetId = 'my-dataset';
  // const dicomStoreId = 'my-dicom-store';
  // const gcsUri = 'my-bucket/my-directory'
  const name = `projects/${projectId}/locations/${cloudRegion}/datasets/${datasetId}/dicomStores/${dicomStoreId}`;
  const request = {
    name,
    resource: {
      gcsDestination: {
        // The destination location of the DICOM instances in Cloud Storage
        uriPrefix: `gs://${gcsUri}`,
        // The format to use for the output files, per the MIME types supported in the DICOM spec
        mimeType: 'application/dicom',
      },
    },
  };

  await healthcare.projects.locations.datasets.dicomStores.export(request);
  console.log(`Exported DICOM instances to ${gcsUri}`);
};

exportDicomInstanceGcs();

Python

def export_dicom_instance(project_id, location, dataset_id, dicom_store_id, uri_prefix):
    """Export data to a Google Cloud Storage bucket by copying
    it from the DICOM store.

    See https://github.com/GoogleCloudPlatform/python-docs-samples/tree/main/healthcare/api-client/v1/dicom
    before running the sample."""
    # Imports the Google API Discovery Service.
    from googleapiclient import discovery

    api_version = "v1"
    service_name = "healthcare"
    # Returns an authorized API client by discovering the Healthcare API
    # and using GOOGLE_APPLICATION_CREDENTIALS environment variable.
    client = discovery.build(service_name, api_version)

    # TODO(developer): Uncomment these lines and replace with your values.
    # project_id = 'my-project'  # replace with your GCP project ID
    # location = 'us-central1'  # replace with the parent dataset's location
    # dataset_id = 'my-dataset'  # replace with the DICOM store's parent dataset ID
    # dicom_store_id = 'my-dicom-store'  # replace with the DICOM store's ID
    # uri_prefix = 'my-bucket'  # replace with a Cloud Storage bucket
    dicom_store_parent = "projects/{}/locations/{}/datasets/{}".format(
        project_id, location, dataset_id
    )
    dicom_store_name = f"{dicom_store_parent}/dicomStores/{dicom_store_id}"

    body = {"gcsDestination": {"uriPrefix": f"gs://{uri_prefix}"}}

    request = (
        client.projects()
        .locations()
        .datasets()
        .dicomStores()
        .export(name=dicom_store_name, body=body)
    )

    response = request.execute()
    print(f"Exported DICOM instances to bucket: gs://{uri_prefix}")

    return response

esportazione DICOM istanze utilizzando filtri

Per impostazione predefinita, quando esporti i file DICOM in Cloud Storage vengono esportati tutti i file DICOM nell'archivio DICOM. Analogamente, quando esporti i metadati DICOM in BigQuery, vengono esportati i metadati di tutti i dati DICOM nell'archivio DICOM.

Puoi esportare un sottoinsieme di dati o metadati DICOM utilizzando un file di filtro.

Configurare un file di filtro

  • Ogni riga nel file filtro definisce lo studio, la serie o l'istanza e utilizza il formato /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID/instances/INSTANCE_UID.
  • Puoi troncare una riga per specificare il livello a cui funziona il filtro. Ad esempio, puoi selezionare un intero studio specificando /studies/STUDY_INSTANCE_UID, oppure puoi selezionare un intere serie specificando /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID.

Considera il seguente file di filtro:

/studies/1.123.456.789
/studies/1.666.333.111/series/123.456
/studies/1.666.333.111/series/567.890
/studies/1.888.999.222/series/123.456/instances/111
/studies/1.888.999.222/series/123.456/instances/222
/studies/1.888.999.222/series/123.456/instances/333

Questo file di filtro di esempio si applica a quanto segue:

  • L'intero studio con l'UID dell'istanza di studio 1.123.456.789
  • Due serie separate con UID di istanze di serie come 123.456 e 567.890 nello studio 1.666.333.111
  • Tre singole istanze con ID istanza come 111, 222 e 333 nel studio 1.888.999.222 e serie 123.456

Creare un file di filtro utilizzando BigQuery

Per creare un file di filtro utilizzando BigQuery, devi prima esportare i metadati dell'archivio DICOM in BigQuery. I metadati esportati mostra gli UID di studio, serie e istanza dei dati DICOM nel .

Dopo aver esportato i metadati, completa i seguenti passaggi:

  1. Esegui una query per restituire gli UID dello studio, della serie e delle istanze che da aggiungere al file di filtro.

    Ad esempio, la seguente query mostra come concatenare lo studio, la serie e UID dell'istanza in modo che corrispondano ai requisiti del formato file del filtro:

    SELECT CONCAT
    ('/studies/', StudyInstanceUID, '/series/', SeriesInstanceUID, '/instances/', SOPInstanceUID)
FROM
    [PROJECT_ID:BIGQUERY_DATASET.BIGQUERY_TABLE]

  2. (Facoltativo) Se la query restituisce un set di risultati di grandi dimensioni che supera il dimensione massima della risposta, salvare i risultati della query in una nuova tabella di destinazione in BigQuery.

  3. Salva i risultati della query in un ed esportarlo in Cloud Storage. Se hai salvato i risultati della query a una nuova tabella di destinazione nel Passaggio 2, consulta Esportazione dei dati della tabella per esportare i dati della tabella in Cloud Storage.

  4. Modifica il file esportato in base alle necessità e includilo nella richiesta per cambiare la classe di archiviazione di più oggetti DICOM.

Creare manualmente un file di filtro

Per creare manualmente un file di filtro:

  1. Crea un file di filtro contenente gli oggetti DICOM su cui stai filtrando.
  2. Carica il file del filtro in Cloud Storage. Per istruzioni, vedi Carica oggetti da un file system.

Passaggio nel file di filtro

Dopo aver creato un file di filtro, chiama l'operazione di esportazione DICOM e invia il file di filtro utilizzando l'API REST. I seguenti esempi mostrano come per esportare i dati DICOM utilizzando un filtro.

gcloud

Per esportare i metadati DICOM in Cloud Storage utilizzando un filtro, utilizza gcloud beta healthcare dicom-stores export gcs :

gcloud beta healthcare dicom-stores export gcs DICOM_STORE_ID \
  --dataset=DATASET_ID \
  --location=LOCATION \
  --gcs-uri-prefix=gs://DESTINATION_BUCKET/DIRECTORY \
  --filter-config-gcs-uri=gs://BUCKET/DIRECTORY/FILTER_FILE

Sostituisci quanto segue:

  • DICOM_STORE_ID: l'identificatore dell'archivio DICOM
  • DATASET_ID: il nome del set di dati padre dell'archivio DICOM
  • LOCATION: la posizione del set di dati principale dell'archivio DICOM
  • DESTINATION_BUCKET/DIRECTORY: il bucket Cloud Storage di destinazione
  • BUCKET/DIRECTORY/FILTER_FILE: la posizione del file del filtro in un bucket Cloud Storage

L'output è il seguente:

Request issued for: [DICOM_STORE_ID]
Waiting for operation [projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID] to complete...done.
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID

Per visualizzare lo stato dell'operazione, esegui il comando gcloud healthcare operations describe e fornisci OPERATION_ID dalla risposta:

gcloud healthcare operations describe OPERATION_ID \
  --location=LOCATION \
  --dataset=DATASET_ID

Sostituisci quanto segue:

  • OPERATION_ID: il numero ID restituito dalla risposta precedente
  • DATASET_ID: il nome del set di dati padre dell'archivio DICOM
  • LOCATION: la posizione del set di dati principale dell'archivio DICOM

L'output è il seguente:

done: true
metadata:
'@type': type.googleapis.com/google.cloud.healthcare.v1beta1.OperationMetadata
apiMethodName: google.cloud.healthcare.v1beta1.dicom.DicomService.ExportDicomData
counter:
  success: SUCCESSFUL_INSTANCES
  failure: FAILED_INSTANCES
createTime: 'CREATE_TIME'
endTime: 'END_TIME'
logsUrl: 'https://console.cloud.google.com/logs/query/CLOUD_LOGGING_URL'
name: projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID
response:
'@type': '...'

API

Per esportare i dati DICOM utilizzando un filtro, utilizza il metodo projects.locations.datasets.dicomStores.export.

curl

Per esportare i dati DICOM utilizzando un file filtro, effettua una richiesta POST e fornisci le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione
  • La posizione del file del filtro in un bucket Cloud Storage

L'esempio seguente mostra una richiesta POST che utilizza curl.

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    --data "{
      'gcsDestination': {
        'uriPrefix': 'gs://BUCKET/DIRECTORY'
      },
      'filterConfig': {
        'resourcePathsGcsUri': 'gs://BUCKET/DIRECTORY/FILTER_FILE'
      }
    }" "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export"

Se la richiesta ha esito positivo, il server restituisce la seguente risposta in JSON formato:

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La risposta contiene il nome di un'operazione. Utilizza la Metodo dell'operazione get per monitorare lo stato dell'operazione:

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_NAME"

Se la richiesta riesce, il server restituisce la seguente risposta in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1beta1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1beta1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME"
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

PowerShell

Per esportare i dati DICOM utilizzando un file di filtro, effettua una richiesta POST e fornisci il metodo le seguenti informazioni:

  • Il nome e la località del set di dati padre
  • Nome dell'archivio DICOM
  • Il bucket Cloud Storage di destinazione
  • La posizione del file del filtro in un bucket Cloud Storage

L'esempio seguente mostra una richiesta POST mediante Windows PowerShell.

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Post `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body "{
    'gcsDestination': {
      'uriPrefix': 'gs://BUCKET/DIRECTORY'
    },
    'filterConfig': {
      'resourcePathsGcsUri': 'gs://BUCKET/DIRECTORY/FILTER_FILE'
  }" `
  -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/dicomStores/DICOM_STORE_ID:export" | Select-Object -Expand Content

Se la richiesta ha esito positivo, il server restituisce la seguente risposta in JSON formato:

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID"
}

La risposta contiene il nome di un'operazione. Utilizza la Metodo dell'operazione get per monitorare lo stato dell'operazione:

$cred = gcloud auth application-default print-access-token
$headers = @{ Authorization = "Bearer $cred" }

Invoke-WebRequest `
  -Method Get `
  -Headers $headers `
  -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_NAME" | Select-Object -Expand Content

Se la richiesta ha esito positivo, il server restituisce la seguente risposta con stato dell'operazione in formato JSON:

{
  "name": "projects/PROJECT_ID/locations/REGION/datasets/DATASET_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.healthcare.v1beta1.OperationMetadata",
    "apiMethodName": "google.cloud.healthcare.v1beta1.dicom.DicomService.ExportDicomData",
    "createTime": "CREATE_TIME",
    "endTime": "END_TIME"
  },
  "done": true,
  "response": {
    "@type": "..."
  }
}

Risoluzione dei problemi delle richieste di esportazione DICOM

Se si verificano errori durante una richiesta di esportazione DICOM, gli errori vengono registrati Cloud Logging. Per ulteriori informazioni, vedi Visualizzazione dei log degli errori in Cloud Logging.

Se l'intera operazione restituisce un errore, consulta la sezione Risoluzione dei problemi relativi alle operazioni a lunga esecuzione.