DICOM-Daten mit Cloud Storage importieren und exportieren

Auf dieser Seite wird erläutert, wie Sie DICOM-Instanzen nach Cloud Storage exportieren und DICOM-Objekte aus Cloud Storage importieren. Eine DICOM-Instanz ist normalerweise ein Bild, kann aber auch ein anderer nichtflüchtiger Datentyp sein, z. B. ein strukturierter Bericht. Ein DICOM-Objekt in Cloud Storage ist eine DICOM-Instanz, die sich in Cloud Storage befindet. Weitere Informationen finden Sie unter Cloud Storage.

Cloud Storage-Berechtigungen festlegen

Bevor Sie DICOM-Daten in Cloud Storage importieren bzw. daraus exportieren können, müssen Sie dem Dienstkonto Cloud Healthcare Service Agent zusätzliche Berechtigungen erteilen. Weitere Informationen finden Sie unter Cloud Storage-Berechtigungen für DICOM-Speicher.

DICOM-Objekte importieren

Sie können eine der folgenden Methoden verwenden, um mehrere DICOM-Instanzdateien in einen DICOM-Speicher zu importieren:

In den folgenden Beispielen wird gezeigt, wie Sie DICOM-Objekte aus einem Cloud Storage-Bucket importieren.

Console

So importieren Sie DICOM-Objekte aus einem Cloud Storage-Bucket:

  1. Rufen Sie in der Google Cloud Console die Seite Datasets auf.
    Zu den Datasets
  2. Klicken Sie auf das Dataset mit dem DICOM-Speicher, in den Sie DICOM-Objekte importieren.
  3. Wählen Sie aus der Liste der Datenspeicher Importieren aus der Liste Aktionen für den DICOM-Speicher aus.

    Die Seite In DICOM-Speicher importieren wird angezeigt.
  4. Wählen Sie in der Liste Projekt ein Cloud Storage-Projekt aus.
  5. Wählen Sie in der Liste Standort einen Cloud Storage-Bucket aus.
  6. So legen Sie einen bestimmten Speicherort für den Import von Dateien fest:
    1. Erweiterte Optionen einblenden.
    2. Wählen Sie Cloud Storage-Pfad überschreiben aus.
    3. Wenn Sie eine bestimmte Quelle für den Import von Dateien festlegen möchten, definieren Sie den Pfad mithilfe der folgenden Variablen im Textfeld Speicherort:
      • *: entspricht Nicht-Trennzeichen.
      • **: entspricht Zeichen, einschließlich Trennzeichen. Dies kann mit einer Dateinamenerweiterung verwendet werden, um alle Dateien desselben Typs abzugleichen.
      • ?: entspricht einem Zeichen.
  7. Klicken Sie auf Importieren, um DICOM-Objekte aus der definierten Quelle zu importieren.
  8. Klicken Sie auf den Tab Vorgänge, um den Status des Vorgangs zu verfolgen. Wenn der Vorgang abgeschlossen ist, werden folgende Hinweise angezeigt:
    • Im Abschnitt Status: Lang andauernder Vorgang befindet sich unter der Überschrift OK ein grünes Häkchen.
    • Der Abschnitt Übersicht hat ein grünes Häkchen und einen OK-Indikator in der Zeile, in der sich auch die Vorgangs-ID befindet.
    Falls Fehler auftreten, klicken Sie auf Aktionen und dann auf Details in Cloud Logging ansehen.

gcloud

Verwenden Sie den Befehl gcloud healthcare dicom-stores import gcs, um DICOM-Objekte aus einem Cloud Storage-Bucket zu importieren. Geben Sie den Namen des übergeordneten Datasets, den Namen des DICOM-Speichers und den Speicherort des Objekts in einem Cloud Storage-Bucket an.

  • Der Speicherort der Dateien im Bucket ist beliebig und muss nicht genau dem im folgenden Beispiel angegebenen Format entsprechen.
  • Wenn Sie den Speicherort der DICOM-Objekte in Cloud Storage angeben, können Sie Platzhalter verwenden, um mehrere Dateien aus einem oder mehreren Verzeichnissen zu importieren. Die folgenden Platzhalter werden unterstützt:
    • Verwenden Sie *, um null oder mehr Nicht-Trennzeichen abzugleichen. Zum Beispiel stimmt gs://BUCKET/DIRECTORY/Example*.dcm mit Example.dcm und Example22.dcm in DIRECTORY überein.
    • Verwenden Sie **, um 0 oder mehr Zeichen (einschließlich Trennzeichen) abzugleichen. Muss am Ende eines Pfads und ohne andere Platzhalter im Pfad verwendet werden. Kann auch mit einer Dateinamenerweiterung wie .dcm verwendet werden, die alle Dateien mit der Dateinamenerweiterung im angegebenen Verzeichnis und in seinen Unterverzeichnissen importiert. Beispiel: gs://BUCKET/DIRECTORY/**.dcm importiert alle Dateien mit der Endung .dcm in DIRECTORY und seinen Unterverzeichnissen.
    • Verwenden Sie ? als Platzhalter für genau 1 Zeichen. Beispiel: gs://BUCKET/DIRECTORY/Example?.dcm stimmt mit Example1.dcm überein, aber nicht mit Example.dcm oder Example01.dcm.

Das folgende Beispiel zeigt, wie DICOM-Objekte aus einem Cloud Storage-Bucket importiert werden.

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

In der Befehlszeile wird die Vorgangs-ID angezeigt:

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

Führen Sie den gcloud healthcare operations describe-Befehl aus und geben Sie OPERATION_ID aus der Antwort an, um den Status des Vorgangs anzuzeigen:

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

Nach Abschluss des Befehls enthält die Antwort 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

Verwenden Sie die Methode projects.locations.datasets.dicomStores.import, um DICOM-Objekte aus einem Cloud Storage-Bucket zu importieren.

  • Der Speicherort der Dateien im Bucket kann variieren und muss nicht dem in den folgenden Beispielen angegebenen Format entsprechen.
  • Wenn Sie den Speicherort der DICOM-Objekte in Cloud Storage angeben, verwenden Sie Platzhalter, um mehrere Dateien aus einem oder mehreren Verzeichnissen zu importieren. Die folgenden Platzhalter werden unterstützt:
    • Verwenden Sie *, um null oder mehr Nicht-Trennzeichen abzugleichen. Zum Beispiel stimmt gs://BUCKET/DIRECTORY/Example*.dcm mit Example.dcm und Example22.dcm in DIRECTORY überein.
    • Verwenden Sie **, um 0 oder mehr Zeichen (einschließlich Trennzeichen) abzugleichen. Muss am Ende eines Pfads und ohne andere Platzhalter im Pfad verwendet werden. Kann auch mit einer Dateinamenerweiterung wie .dcm verwendet werden, die alle Dateien mit der Dateinamenerweiterung im angegebenen Verzeichnis und in seinen Unterverzeichnissen importiert. Beispiel: gs://BUCKET/DIRECTORY/**.dcm importiert alle Dateien mit der Endung .dcm in DIRECTORY und seinen Unterverzeichnissen.
    • Verwenden Sie ? als Platzhalter für genau 1 Zeichen. Beispiel: gs://BUCKET/DIRECTORY/Example?.dcm stimmt mit Example1.dcm überein, aber nicht mit Example.dcm oder Example01.dcm.

REST

  1. Importieren Sie das DICOM-Objekt.

    Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

    • PROJECT_ID ist die ID Ihres Google Cloud-Projekts
    • LOCATION ist der Standort des Datasets
    • DATASET_ID ist das übergeordnete Dataset des DICOM-Speichers
    • DICOM_STORE_ID ist die ID des DICOM-Speichers
    • BUCKET/PATH/TO/FILE: der Pfad zum DICOM-Objekt in Cloud Storage

    JSON-Text anfordern: 

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

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    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

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    $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
    Die Ausgabe sieht so aus. Die Antwort enthält eine Kennung für einen Vorgang mit langer Ausführungszeit. Lang andauernde Vorgänge werden zurückgegeben, wenn die Ausführung von Methodenaufrufen sehr lange dauern kann. Notieren Sie sich den Wert von OPERATION_ID. Sie benötigen diesen Wert im nächsten Schritt.

  2. Rufen Sie den Status des Vorgangs mit langer Ausführungszeit ab.

    Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

    • PROJECT_ID ist die ID Ihres Google Cloud-Projekts
    • LOCATION ist der Standort des Datasets
    • DATASET_ID: das übergeordnete Dataset des DICOM-Speichers
    • OPERATION_ID ist die ID, die vom lang andauernden Vorgang zurückgegeben wurde

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Führen Sie folgenden Befehl aus: 

    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

    Führen Sie folgenden Befehl aus: 

    $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
    Wenn der lang andauernde Vorgang noch ausgeführt wird, gibt der Server eine Antwort mit der Anzahl der DICOM-Instanzen zurück, die noch importiert werden müssen. Wenn der Vorgang erfolgreich abgeschlossen wurde, gibt der Server eine Antwort mit dem Status des Vorgangs im JSON-Format zurück:

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

Zum Abrufen einer einzelnen Instanz oder Studie aus einem DICOM-Speicher rufen Sie DICOM-Daten mit dem RESTful-Webdienst Abrufen von Transaktionen ab, der in der Cloud Healthcare API implementiert ist.

Speicherklasse zum Importieren von DICOM-Objekten angeben (Vorschau)

Standardmäßig importiert die Methode projects.locations.datasets.dicomStores.import ein DICOM-Objekt in einen DICOM-Speicher mit einer Standardspeicherklasse. Sie können die Speicherklasse festlegen, wenn Sie DICOM-Objekte aus Cloud Storage importieren. Weitere Informationen finden Sie unter DICOM-Speicherklasse ändern.

In den folgenden Beispielen wird gezeigt, wie Sie die Speicherklasse angeben, wenn Sie DICOM-Objekte aus Cloud Storage importieren.

REST

Verwenden Sie die Methode projects.locations.datasets.dicomStores.import.

  1. Importieren Sie das DICOM-Objekt.

    Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

    • PROJECT_ID ist die ID Ihres Google Cloud-Projekts
    • LOCATION ist der Standort des Datasets
    • DATASET_ID ist das übergeordnete Dataset des DICOM-Speichers
    • DICOM_STORE_ID ist die ID des DICOM-Speichers
    • BUCKET/PATH/TO/FILE: der Pfad zum DICOM-Objekt in Cloud Storage
    • STORAGE_CLASS: die Speicherklasse für das DICOM-Objekt im DICOM-Speicher aus STANDARD, NEARLINE, COLDLINE und ARCHIVE

    JSON-Text anfordern: 

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

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    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

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json. Führen Sie folgenden Befehl im Terminal aus, um diese Datei im aktuellen Verzeichnis zu erstellen oder zu überschreiben: 

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

    Führen Sie dann folgenden Befehl aus, um Ihre REST-Anfrage zu senden: 

    $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
    Die Ausgabe sieht so aus. Die Antwort enthält eine Kennung für einen Vorgang mit langer Ausführungszeit. Lang andauernde Vorgänge werden zurückgegeben, wenn die Ausführung von Methodenaufrufen sehr lange dauern kann. Notieren Sie sich den Wert von OPERATION_ID. Sie benötigen diesen Wert im nächsten Schritt.

  2. Rufen Sie den Status des Vorgangs mit langer Ausführungszeit ab.

    Bevor Sie die Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

    • PROJECT_ID ist die ID Ihres Google Cloud-Projekts
    • LOCATION ist der Standort des Datasets
    • DATASET_ID: das übergeordnete Dataset des DICOM-Speichers
    • OPERATION_ID ist die ID, die vom lang andauernden Vorgang zurückgegeben wurde

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Führen Sie folgenden Befehl aus: 

    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

    Führen Sie folgenden Befehl aus: 

    $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
    Wenn der lang andauernde Vorgang noch ausgeführt wird, gibt der Server eine Antwort mit der Anzahl der DICOM-Instanzen zurück, die noch importiert werden müssen. Wenn der Vorgang abgeschlossen ist, gibt der Server eine Antwort mit dem Status des Vorgangs im JSON-Format zurück:

Fehlerbehebung bei DICOM-Importanfragen

Wenn während einer DICOM-Importanfrage Fehler auftreten, werden die Fehler in Cloud Logging protokolliert. Weitere Informationen finden Sie unter Fehlerlogs in Cloud Logging ansehen.

DICOM-Instanzen exportieren

In den folgenden Beispielen wird gezeigt, wie Sie DICOM-Instanzen in einen Cloud Storage-Bucket exportieren. Wenn Sie DICOM-Instanzen aus einem DICOM-Speicher exportieren, werden alle Instanzen aus dem Speicher exportiert.

Console

So exportieren Sie DICOM-Instanzen nach Cloud Storage:

  1. Rufen Sie in der Google Cloud Console die Seite Datasets auf.
    Zu den Datasets
  2. Klicken Sie auf das Dataset, das den DICOM-Speicher enthält, aus dem Sie DICOM-Instanzen exportieren.
  3. Wählen Sie in der Liste der Datenspeicher aus der Liste Aktionen für den DICOM-Speicher Exportieren aus.
  4. Wählen Sie auf der Seite DICOM-Speicher exportieren die Option Google Cloud Storage-Bucket aus.
  5. Wählen Sie in der Liste Projekt ein Cloud Storage-Projekt aus.
  6. Wählen Sie in der Liste Standort einen Cloud Storage-Bucket aus.
  7. Wählen Sie in den DICOM-Exporteinstellungen den Dateityp aus, mit dem die DICOM-Instanzen exportiert werden sollen. Die folgenden Typen sind verfügbar:
    • DICOM-Datei (.dcm)
    • octet-stream
    • Bild (.jpg, .png)
  8. Um eine zusätzliche Übertragungssyntax zu definieren, wählen Sie diese aus der Liste Übertragungssyntax aus.
  9. Klicken Sie auf Exportieren, um DICOM-Instanzen an den definierten Speicherort in Cloud Storage zu exportieren.
  10. Klicken Sie auf den Tab Vorgänge, um den Status des Vorgangs zu verfolgen. Wenn der Vorgang abgeschlossen ist, werden folgende Hinweise angezeigt:
    • Im Abschnitt Status: Lang andauernder Vorgang befindet sich unter der Überschrift OK ein grünes Häkchen.
    • Der Abschnitt Übersicht hat ein grünes Häkchen und einen OK-Indikator in der Zeile, in der sich auch die Vorgangs-ID befindet.
    Falls Fehler auftreten, klicken Sie auf Aktionen und dann auf Details in Cloud Logging ansehen.

gcloud

Verwenden Sie den Befehl gcloud healthcare dicom-stores export gcs, um DICOM-Instanzen in einen Cloud Storage-Bucket zu exportieren.

  • Geben Sie den Namen des übergeordneten Datasets, den Namen des DICOM-Speichers und den Cloud Storage-Ziel-Bucket an.
  • Schreiben Sie in einen Cloud Storage-Bucket oder ein Cloud Storage-Verzeichnis und nicht in ein Objekt, da die Cloud Healthcare API für jedes Objekt eine .dcm-Datei erstellt.
  • Wenn der Befehl ein nicht vorhandenes Verzeichnis angibt, wird das Verzeichnis erstellt.

Das folgende Beispiel zeigt den Befehl 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

In der Befehlszeile wird die Vorgangs-ID angezeigt:

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

Führen Sie den gcloud healthcare operations describe-Befehl aus und geben Sie OPERATION_ID aus der Antwort an, um den Status des Vorgangs anzuzeigen:

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

Nach Abschluss des Befehls enthält die Antwort 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

Verwenden Sie die Methode projects.locations.datasets.dicomStores.export, um DICOM-Instanzen in einen Cloud Storage-Bucket zu exportieren.

  • Schreiben Sie in einen Cloud Storage-Bucket oder ein Cloud Storage-Verzeichnis und nicht in ein Objekt, da die Cloud Healthcare API für jedes Objekt eine .dcm-Datei erstellt.
  • Wenn der Befehl ein nicht vorhandenes Verzeichnis angibt, wird das Verzeichnis erstellt.

curl

Zum Exportieren von DICOM-Instanzen senden Sie eine POST-Anfrage und geben die folgenden Informationen an:

  • Name und Speicherort des übergeordneten Datasets
  • Der Name des DICOM-Speichers
  • Der Cloud Storage-Ziel-Bucket

Das folgende Beispiel zeigt eine POST-Anfrage mit 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"

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

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

Die Antwort enthält einen Vorgangsnamen. Mit der Vorgangsmethode get können Sie den Status des Vorgangs verfolgen:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server eine Antwort mit dem Status des Vorgangs im JSON-Format zurück:

{
  "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

Zum Exportieren von DICOM-Instanzen senden Sie eine POST-Anfrage und geben die folgenden Informationen an:

  • Name und Speicherort des übergeordneten Datasets
  • Der Name des DICOM-Speichers
  • Der Cloud Storage-Ziel-Bucket

Das folgende Beispiel zeigt eine POST-Anfrage mit 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

Wenn die Anfrage erfolgreich ist, gibt der Server die Antwort im JSON-Format zurück:

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

Die Antwort enthält einen Vorgangsnamen. Mit der Vorgangsmethode get können Sie den Status des Vorgangs verfolgen:

$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

Wenn die Anfrage erfolgreich ist, gibt der Server eine Antwort mit dem Status des Vorgangs im JSON-Format zurück:

{
  "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

DICOM-Instanzen mithilfe von Filtern exportieren

Wenn Sie DICOM-Dateien in Cloud Storage exportieren, werden standardmäßig alle DICOM-Dateien im DICOM-Speicher exportiert. Ebenso werden beim Exportieren von DICOM-Metadaten nach BigQuery die Metadaten für alle DICOM-Daten im DICOM-Speicher exportiert.

Sie können eine Teilmenge der DICOM-Daten oder -Metadaten mithilfe einer Filterdatei exportieren.

Filterdatei konfigurieren

Mit einer Filterdatei können Sie die Liste der DICOM-Dateien definieren, die nach Cloud Storage oder BigQuery exportiert werden sollen.

Jede Zeile in der Filterdatei definiert die Studie, Serie oder Instanz und verwendet das Format /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID/instances/INSTANCE_UID.

Sie können eine Zeile abschneiden, um festzulegen, auf welcher Ebene der Filter funktioniert. Sie können beispielsweise eine gesamte Studie exportieren, indem Sie /studies/STUDY_INSTANCE_UID angeben, oder eine ganze Reihe exportieren, indem Sie /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID angeben.

Betrachten Sie die folgende Filterdatei:

/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

Mit dieser Filterdatei wird Folgendes gefiltert:

  • Die gesamte Studie mit der UID der Studieninstanz als 1.123.456.789
  • Zwei separate Reihen mit Serieninstanz-UIDs wie 123.456 und 567.890 in der Studie 1.666.333.111
  • Drei einzelne Instanzen mit Instanz-IDs als 111, 222 und 333 in der Studie 1.888.999.222 und der Serie 123.456

Filterdatei mit BigQuery erstellen

Zum Erstellen einer Filterdatei mit BigQuery müssen Sie die Metadaten Ihres DICOM-Speichers nach BigQuery exportieren. Die exportierten Metadaten zeigen die Studien-, Reihen- und Instanz-UIDs der DICOM-Daten in Ihrem DICOM-Speicher.

Führen Sie nach dem Export die folgenden Schritte aus:

  1. Fragen Sie die erforderlichen Studien-, Reihen- und Instanz-UIDs ab.

    Führen Sie nach dem Exportieren von DICOM-Metadaten nach BigQuery beispielsweise die folgende Abfrage aus, um die Studien-, Reihen- und Instanz-UIDs zu verketten, damit sie den Anforderungen an das Filterdateiformat entsprechen:

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

  2. Optional: Wenn die Abfrage eine große Ergebnismenge zurückgibt, die die maximale Antwortgröße überschreitet, speichern Sie die Abfrageergebnisse in einer neuen Zieltabelle in BigQuery.

  3. Speichern Sie die Abfrageergebnisse in einer Datei und exportieren Sie sie in Cloud Storage. Wenn Sie die Abfrageergebnisse in Schritt 2 in einer neuen Zieltabelle gespeichert haben, erfahren Sie unter Tabellendaten exportieren, wie Sie die Inhalte der Tabelle nach Cloud Storage exportieren.

  4. Bearbeiten Sie die exportierte Datei nach Bedarf und verwenden Sie sie als Filterdatei. Der Speicherort der Filterdatei in Cloud Storage ist im Exportvorgang erforderlich.

Filterdatei manuell erstellen

So erstellen Sie eine Filterdatei mit benutzerdefiniertem Inhalt und laden sie in einen Cloud Storage-Bucket hoch:

  1. Erstellen Sie eine Filterdatei mit einer Liste von Instanzen, deren Speicherklasse auf dem lokalen Computer geändert werden muss. Verwenden Sie das im Abschnitt Filterdatei konfigurieren beschriebene Format.

  2. Laden Sie die Filtertextdatei an einen Cloud Storage-Speicherort hoch.

    gsutil cp PATH_TO_FILTER_FILE/FILTER_FILE_NAME.txt gs://BUCKET/DIRECTORY

    Ersetzen Sie Folgendes:

    • PATH_TO_FILTER_FILE: der Pfad zur Filterdatei auf Ihrem lokalen Computer
    • FILTER_FILE_NAME: der Name der Filterdatei
    • BUCKET/DIRECTORY: der Pfad zum Cloud Storage-Speicherort

    Beispiel: 

    gsutil cp my-local-folder/archive-filters.txt gs://my-bucket/my-directory

Filterdatei übergeben

Nachdem Sie eine Filterdatei erstellt haben, können Sie den DICOM-Exportvorgang aufrufen und die Filterdatei mit der REST API übergeben. In folgenden Beispielen wird gezeigt, wie Sie DICOM-Daten mit einem Filter exportieren.

gcloud

Verwenden Sie den Befehl gcloud beta healthcare dicom-stores export gcs, um DICOM-Metadaten mithilfe eines Filters nach Cloud Storage zu exportieren:

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

Ersetzen Sie Folgendes:

  • DICOM_STORE_ID ist die Kennung für den DICOM-Speicher
  • DATASET_ID ist der Name des übergeordneten Datasets des DICOM-Speichers
  • LOCATION ist der Speicherort des übergeordneten Datasets des DICOM-Speichers
  • DESTINATION_BUCKET/DIRECTORY ist der Ziel-Bucket von Cloud Storage
  • BUCKET/DIRECTORY/FILTER_FILE ist der Speicherort der Filterdatei in einem Cloud Storage-Bucket

Die Ausgabe sieht so aus:

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

Führen Sie den gcloud healthcare operations describe-Befehl aus und geben Sie OPERATION_ID aus der Antwort an, um den Status des Vorgangs anzuzeigen:

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

Ersetzen Sie Folgendes:

  • OPERATION_ID ist die ID-Nummer, die von der vorherigen Antwort zurückgegeben wurde
  • DATASET_ID ist der Name des übergeordneten Datasets des DICOM-Speichers
  • LOCATION ist der Speicherort des übergeordneten Datasets des DICOM-Speichers

Die Ausgabe sieht so aus:

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

Verwenden Sie die Methode projects.locations.datasets.dicomStores.export, um DICOM-Daten mithilfe eines Filters zu exportieren.

curl

Wenn Sie DICOM-Daten mithilfe einer Filterdatei exportieren möchten, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

  • Name und Speicherort des übergeordneten Datasets
  • Der Name des DICOM-Speichers
  • Der Cloud Storage-Ziel-Bucket
  • Der Speicherort der Filterdatei in einem Cloud Storage-Bucket

Das folgende Beispiel zeigt eine POST-Anfrage mit 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"

Wenn die Anfrage erfolgreich ist, gibt der Server die folgende Antwort im JSON-Format zurück:

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

Die Antwort enthält einen Vorgangsnamen. Verwenden Sie die Vorgangsmethode get, um den Status des Vorgangs zu verfolgen:

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"

Wenn die Anfrage erfolgreich ist, gibt der Server die folgende Antwort im JSON-Format zurück:

{
  "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

Wenn Sie DICOM-Daten mithilfe einer Filterdatei exportieren möchten, senden Sie eine POST-Anfrage und geben Sie die folgenden Informationen an:

  • Name und Speicherort des übergeordneten Datasets
  • Der Name des DICOM-Speichers
  • Der Cloud Storage-Ziel-Bucket
  • Der Speicherort der Filterdatei in einem Cloud Storage-Bucket

Das folgende Beispiel zeigt eine POST-Anfrage mit 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

Wenn die Anfrage erfolgreich ist, gibt der Server die folgende Antwort im JSON-Format zurück:

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

Die Antwort enthält einen Vorgangsnamen. Verwenden Sie die Vorgangsmethode get, um den Status des Vorgangs zu verfolgen:

$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

Wenn die Anfrage erfolgreich ist, gibt der Server die folgende Antwort mit dem Status des Vorgangs im JSON-Format zurück:

{
  "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": "..."
  }
}

Fehlerbehebung bei DICOM-Exportanfragen

Wenn während einer DICOM-Exportanfrage Fehler auftreten, werden die Fehler in Cloud Logging protokolliert. Weitere Informationen finden Sie unter Fehlerlogs in Cloud Logging ansehen.

Wenn der gesamte Vorgang einen Fehler zurückgibt, finden Sie weitere Informationen unter Fehlerbehebung bei Vorgängen mit langer Ausführungszeit.