Importer et exporter des données DICOM à l'aide de Cloud Storage

Cette page explique comment importer des objets DICOM depuis Cloud Storage et comment y exporter des instances DICOM. Une instance DICOM est généralement une image, mais elle peut être un autre type de données persistantes, comme un rapport structuré. Un objet DICOM dans Cloud Storage est une instance DICOM qui réside Cloud Storage. Pour en savoir plus, consultez la page Cloud Storage.

Définir des autorisations Cloud Storage

Avant d'importer des données DICOM depuis Cloud Storage ou de les exporter vers ce service, vous devez accorder des autorisations supplémentaires au compte de service Agent de service Cloud Healthcare. Pour en savoir plus, consultez la section Autorisations Cloud Storage pour les datastores DICOM.

Importer des objets DICOM

Pour importer plusieurs fichiers d'instance DICOM dans un magasin DICOM, vous pouvez utilisez l'une des méthodes suivantes:

Les exemples suivants montrent comment importer des objets DICOM depuis un bucket Cloud Storage.

Console

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, procédez comme suit :

  1. Dans la console Google Cloud, accédez à la page Ensembles de données.
    Accéder à la page "Ensembles de données"
  2. Cliquez sur l'ensemble de données contenant le magasin DICOM dans lequel vous importez des objets DICOM.
  3. Dans la liste de datastores, sélectionnez Importer dans la liste Actions du magasin DICOM.

    L'importation dans le magasin DICOM s'affiche.
  4. Dans la liste Projet, sélectionnez un projet Cloud Storage.
  5. Dans la liste Emplacement, sélectionnez un bucket Cloud Storage.
  6. Pour définir un emplacement spécifique pour l'importation de fichiers, procédez comme suit :
    1. Développer les options avancées
    2. Sélectionnez Remplacer le chemin d'accès Cloud Storage.
    3. Pour définir une source spécifique pour l'importation de fichiers, définissez le chemin d'accès à l'aide des variables suivantes dans la zone de texte Emplacement :
      • * - correspond aux caractères non séparateurs.
      • ** - correspond aux caractères, y compris les séparateurs. Cela peut être utilisé avec une extension de nom de fichier pour correspondre à tous les fichiers du même type.
      • ? - correspond à 1 caractère.
  7. Cliquez sur Importer pour importer des objets DICOM à partir de la source définie.
  8. Pour suivre l'état de l'opération, cliquez sur l'onglet Opérations. Une fois l'opération terminée, les indications suivantes s'affichent :
    • La section État de l'opération de longue durée est représentée par une coche verte sous l'en-tête OK.
    • La section Présentation comporte une coche verte et un indicateur OK sur la même ligne que l'ID de l'opération.
    Si vous rencontrez des erreurs, cliquez sur Actions, puis sur Afficher les détails dans Cloud Logging.

gcloud

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, utilisez la commande gcloud healthcare dicom-stores import gcs. Spécifiez le nom de l'ensemble de données parent, le nom du magasin DICOM et l'emplacement de l'objet dans un bucket Cloud Storage.

  • L'emplacement des fichiers dans le bucket est arbitraire et ne doit pas nécessairement respecter exactement le format spécifié dans l'exemple suivant.
  • Lorsque vous spécifiez l'emplacement des objets DICOM dans Cloud Storage, vous pouvez importer plusieurs fichiers depuis un ou plusieurs répertoires au moyen de caractères génériques. Les caractères génériques suivants sont acceptés :
    • Utilisez * pour correspondre à 0 ou plusieurs caractères non séparateurs. Par exemple, gs://BUCKET/DIRECTORY/Example*.dcm correspond à Example.dcm et Example22.dcm dans DIRECTORY.
    • Utilisez ** pour correspondre à 0 caractère ou plus (séparateurs compris). Doit être utilisé à la fin d'un chemin d'accès et sans autres caractères génériques. Peut également être utilisé avec une extension de nom de fichier (.dcm, par exemple), qui importe tous les fichiers portant l'extension dans le répertoire spécifié et ses sous-répertoires. Par exemple, gs://BUCKET/DIRECTORY/**.dcm importe tous les fichiers portant l'extension .dcm dans DIRECTORY et ses sous-répertoires.
    • Utilisez ? pour correspondre à 1 caractère. Par exemple, gs://BUCKET/DIRECTORY/Example?.dcm correspond à "Example1.dcm", mais ne correspond pas à "Example.dcm" ou "Example01.dcm".

L'exemple suivant montre comment importer des objets DICOM à partir d'un 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 ligne de commande affiche l'ID de l'opération :

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

Pour afficher l'état de l'opération, exécutez la commande gcloud healthcare operations describe et spécifiez OPERATION_ID dans la réponse :

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

Une fois la commande terminée, la réponse inclut 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

Pour importer des objets DICOM à partir d'un bucket Cloud Storage, utilisez la méthode projects.locations.datasets.dicomStores.import.

  • L'emplacement des fichiers dans le bucket peut varier et n'a pas besoin correspondre au format spécifié dans les exemples suivants.
  • Lorsque vous spécifiez l'emplacement des objets DICOM dans Cloud Storage, vous pouvez importer plusieurs fichiers depuis un ou plusieurs répertoires au moyen de caractères génériques. Les caractères génériques suivants sont acceptés :
    • Utilisez * pour correspondre à 0 ou plusieurs caractères non séparateurs. Par exemple, gs://BUCKET/DIRECTORY/Example*.dcm correspond à Example.dcm et Example22.dcm dans DIRECTORY.
    • Utilisez ** pour correspondre à 0 caractère ou plus (séparateurs compris). Doit être utilisé à la fin d'un chemin d'accès et sans autres caractères génériques. Peut également être utilisé avec une extension de nom de fichier (.dcm, par exemple), qui importe tous les fichiers portant l'extension dans le répertoire spécifié et ses sous-répertoires. Par exemple, gs://BUCKET/DIRECTORY/**.dcm importe tous les fichiers portant l'extension .dcm dans DIRECTORY et ses sous-répertoires.
    • Utilisez ? pour correspondre à 1 caractère. Par exemple, gs://BUCKET/DIRECTORY/Example?.dcm correspond à "Example1.dcm", mais ne correspond pas à "Example.dcm" ou "Example01.dcm".

REST

  1. Importez l'objet DICOM.

    Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

    • PROJECT_ID : ID de votre projet Google Cloud
    • LOCATION : emplacement de l'ensemble de données
    • DATASET_ID : ensemble de données parent du magasin DICOM
    • DICOM_STORE_ID : ID du magasin DICOM
    • BUCKET/PATH/TO/FILE: chemin d'accès à l'objet DICOM dans Cloud Storage

    Corps JSON de la requête :

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

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

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

    Exécutez ensuite la commande suivante pour envoyer votre requête 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

    Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

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

    Exécutez ensuite la commande suivante pour envoyer votre requête 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
    Le résultat est le suivant. La réponse contient un identifiant pour une opération de longue durée. Les opérations de longue durée sont renvoyées lorsque les appels de méthode peuvent prendre un temps considérable. Notez la valeur de OPERATION_ID. Vous aurez besoin de cette valeur à l'étape suivante.

  2. Obtenez l'état de l'opération de longue durée.

    Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

    • PROJECT_ID : ID de votre projet Google Cloud
    • LOCATION : emplacement de l'ensemble de données
    • DATASET_ID : ensemble de données parent du magasin DICOM
    • OPERATION_ID : ID renvoyé par l'opération de longue durée

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Exécutez la commande suivante :

    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

    Exécutez la commande suivante :

    $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
    Si l'opération de longue durée est toujours en cours d'exécution, le serveur renvoie une réponse avec le nombre d'instances DICOM en attente d'importation. Une fois l'opération de longue durée terminée, le serveur renvoie une réponse indiquant l'état de l'opération au format 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

Pour récupérer une seule instance ou étude à partir d'un magasin DICOM, vous pouvez récupérer des données DICOM à l'aide du service Web RESTful Retrieve Transaction mis en œuvre dans l'API Cloud Healthcare.

Spécifier une classe de stockage pour importer des objets DICOM (preview)

Par défaut, la méthode projects.locations.datasets.dicomStores.import importe un objet DICOM vers un magasin DICOM avec une classe de stockage standard. Vous pouvez définir le paramètre lorsque vous importez des objets DICOM depuis Cloud Storage. Pour en savoir plus, consultez Modifiez la classe de stockage DICOM.

Les exemples suivants montrent comment spécifier la classe de stockage lorsque vous importez Objets DICOM depuis Cloud Storage.

REST

Utilisez la méthode projects.locations.datasets.dicomStores.import.

  1. Importez l'objet DICOM.

    Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

    • PROJECT_ID : ID de votre projet Google Cloud
    • LOCATION : emplacement de l'ensemble de données
    • DATASET_ID : ensemble de données parent du magasin DICOM
    • DICOM_STORE_ID : ID du magasin DICOM
    • BUCKET/PATH/TO/FILE: chemin d'accès à l'objet DICOM dans Cloud Storage
    • STORAGE_CLASS: classe de stockage de l'objet DICOM dans le magasin DICOM à partir de STANDARD, NEARLINE, COLDLINE et ARCHIVE

    Corps JSON de la requête :

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

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

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

    Exécutez ensuite la commande suivante pour envoyer votre requête 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

    Enregistrez le corps de la requête dans un fichier nommé request.json. Exécutez la commande suivante dans le terminal pour créer ou écraser ce fichier dans le répertoire actuel :

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

    Exécutez ensuite la commande suivante pour envoyer votre requête 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
    Le résultat est le suivant. La réponse contient un identifiant pour une opération de longue durée. Les opérations de longue durée sont renvoyées lorsque les appels de méthode peuvent prendre un temps considérable. Notez la valeur de OPERATION_ID. Vous aurez besoin de cette valeur à l'étape suivante.

  2. Obtenez l'état de l'opération de longue durée.

    Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

    • PROJECT_ID : ID de votre projet Google Cloud
    • LOCATION : emplacement de l'ensemble de données
    • DATASET_ID : ensemble de données parent du magasin DICOM
    • OPERATION_ID : ID renvoyé par l'opération de longue durée

    Pour envoyer votre requête, choisissez l'une des options suivantes :

    curl

    Exécutez la commande suivante :

    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

    Exécutez la commande suivante :

    $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
    Si l'opération de longue durée est toujours en cours d'exécution, le serveur renvoie une réponse avec le nombre d'instances DICOM en attente d'importation. Une fois l'opération de longue durée terminée, le serveur renvoie une réponse indiquant l'état de l'opération au format JSON:

Résoudre les problèmes liés aux requêtes d'importation DICOM

Si des erreurs se produisent lors d'une requête d'importation DICOM, elles sont consignées dans Cloud Logging. Pour en savoir plus, consultez la section Afficher les journaux d'erreurs dans Cloud Logging.

Exporter des instances DICOM

Les exemples suivants montrent comment exporter des instances DICOM vers un bucket Cloud Storage. Lorsque vous exportez des instances DICOM depuis un datastore DICOM, toutes les instances qu'il contient sont exportées.

Console

Pour exporter des instances DICOM vers Cloud Storage, procédez comme suit :

  1. Dans la console Google Cloud, accédez à la page Ensembles de données.
    Accéder à la page "Ensembles de données"
  2. Cliquez sur l'ensemble de données contenant le magasin DICOM à partir duquel vous exportez des instances DICOM.
  3. Dans la liste des datastores, sélectionnez Exporter dans la liste Actions du magasin DICOM.
  4. Sur la page Exporter un magasin DICOM qui s'affiche, sélectionnez Bucket Google Cloud Storage.
  5. Dans la liste Projet, sélectionnez un projet Cloud Storage.
  6. Dans la liste Emplacement, sélectionnez un bucket Cloud Storage.
  7. Dans Paramètres d'exportation DICOM, sélectionnez le type de fichier utilisé pour exporter les instances DICOM. Les types suivants sont disponibles :
    • Fichier DICOM (.dcm)
    • Octetstream
    • Image (.jpg, .png)
  8. Pour définir une syntaxe de transfert supplémentaire, sélectionnez-la dans la liste Syntaxe de transfert.
  9. Cliquez sur Exporter pour exporter des instances DICOM vers l'emplacement défini dans Cloud Storage.
  10. Pour suivre l'état de l'opération, cliquez sur l'onglet Opérations. Une fois l'opération terminée, les indications suivantes s'affichent :
    • La section État de l'opération de longue durée est représentée par une coche verte sous l'en-tête OK.
    • La section Présentation comporte une coche verte et un indicateur OK sur la même ligne que l'ID de l'opération.
    Si vous rencontrez des erreurs, cliquez sur Actions, puis sur Afficher les détails dans Cloud Logging.

gcloud

Pour exporter des instances DICOM vers un bucket Cloud Storage, utilisez la commande gcloud healthcare dicom-stores export gcs.

  • Indiquez le nom de l'ensemble de données parent, le nom du magasin DICOM et le bucket Cloud Storage de destination.
  • Écrivez dans un bucket ou un répertoire Cloud Storage plutôt qu'un objet, car l'API Cloud Healthcare crée un fichier .dcm pour chaque objet.
  • Si la commande spécifie un répertoire qui n'existe pas, celui-ci est créé.

L'exemple suivant montre la commande 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 ligne de commande affiche l'ID de l'opération :

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

Pour afficher l'état de l'opération, exécutez la commande gcloud healthcare operations describe et spécifiez OPERATION_ID dans la réponse :

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

Une fois la commande terminée, la réponse inclut 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

Pour exporter des instances DICOM vers un bucket Cloud Storage, utilisez la méthode projects.locations.datasets.dicomStores.export.

  • Écrivez dans un bucket ou un répertoire Cloud Storage plutôt qu'un objet, car l'API Cloud Healthcare crée un fichier .dcm pour chaque objet DICOM.
  • Si la commande spécifie un répertoire qui n'existe pas, celui-ci est créé.

curl

Pour exporter des instances DICOM, envoyez une requête POST et fournissez les informations suivantes :

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination

L'exemple suivant montre une requête POST utilisant 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"

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, utilisez la méthode 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"

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format 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

Pour exporter des instances DICOM, envoyez une requête POST et fournissez les informations suivantes :

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination

L'exemple suivant montre une requête POST utilisant 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

Si la requête aboutit, le serveur renvoie la réponse au format JSON :

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

La réponse contient un nom d'opération. Pour suivre l'état de l'opération, utilisez la méthode 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

Si la requête aboutit, le serveur renvoie une réponse avec l'état de l'opération au format 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

Exporter des instances DICOM à l'aide de filtres

Par défaut, lorsque vous exportez des fichiers DICOM vers Cloud Storage, tous les fichiers DICOM du magasin DICOM sont exportés. De même, lorsque vous exportez des fichiers DICOM vers BigQuery, les métadonnées de toutes les données DICOM dans le store DICOM est exporté.

Vous pouvez exporter un sous-ensemble de données ou de métadonnées DICOM à l'aide d'un fichier de filtre.

Configurer un fichier de filtre

  • Chaque ligne du fichier de filtre définit l'étude, la série ou l'instance et utilise le format /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID/instances/INSTANCE_UID.
  • Vous pouvez tronquer une ligne pour indiquer le niveau auquel le filtre fonctionne. Par exemple, vous pouvez sélectionner une étude entière en spécifiant /studies/STUDY_INSTANCE_UID ou vous pouvez sélectionner une une série entière en spécifiant /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID

Prenons l'exemple du fichier de filtre suivant:

/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

Cet exemple de fichier de filtre s'applique aux éléments suivants:

  • L'ensemble de l'étude avec l'UID de l'instance de l'étude comme 1.123.456.789
  • Deux séries distinctes avec des UID d'instance de série en tant que 123.456 et 567.890 dans l'étude 1.666.333.111
  • Trois instances individuelles avec les ID d'instance 111, 222 et 333 dans le étude 1.888.999.222 et série 123.456

Créer un fichier de filtre à l'aide de BigQuery

Pour créer un fichier de filtre à l'aide de BigQuery, vous devez d'abord exporter les métadonnées de votre magasin DICOM vers BigQuery. Les métadonnées exportées vous montre les UID des études, séries et instances des données DICOM de votre Google Store.

Après avoir exporté les métadonnées, procédez comme suit:

  1. Exécutez une requête pour renvoyer les UID de l'étude, de la série et des instances que vous vous souhaitez ajouter au fichier de filtre.

    Par exemple, la requête suivante montre comment concaténer l'étude, la série et UID de l'instance pour respecter les exigences du format de fichier du filtre:

    SELECT CONCAT
        ('/studies/', StudyInstanceUID, '/series/', SeriesInstanceUID, '/instances/', SOPInstanceUID)
    FROM
        [PROJECT_ID:BIGQUERY_DATASET.BIGQUERY_TABLE]
  2. Facultatif : Si la requête renvoie un grand ensemble de résultats qui dépasse la taille de réponse maximale, enregistrez les résultats de la requête dans une nouvelle table de destination dans BigQuery.

  3. Enregistrez les résultats de la requête et l'exporter vers Cloud Storage. Si vous avez enregistré les résultats de votre requête vers une nouvelle table de destination à l'étape 2, consultez Exporter les données d'une table pour exporter les données contenus dans Cloud Storage.

  4. Modifiez le fichier exporté si nécessaire et incluez-le dans votre demande modifier la classe de stockage de plusieurs objets DICOM.

Créer un fichier de filtre manuellement

Pour créer manuellement un fichier de filtre, procédez comme suit :

  1. Créez un fichier de filtre contenant les objets DICOM sur lesquels vous effectuez le filtrage.
  2. Importez le fichier de filtre dans Cloud Storage. Pour obtenir des instructions, consultez l'article Importer des objets à partir d'un système de fichiers

Transmettre le fichier de filtre

Après avoir créé un fichier de filtre, appelez l'opération d'exportation DICOM et transmettez le fichier de filtre à l'aide de l'API REST. Les exemples suivants montrent comment exporter des données DICOM à l'aide d'un filtre.

gcloud

Pour exporter des métadonnées DICOM vers Cloud Storage à l'aide d'un filtre, utilisez la commande 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

Remplacez les éléments suivants :

  • DICOM_STORE_ID : identifiant du magasin DICOM
  • DATASET_ID : nom de l'ensemble de données parent du magasin DICOM
  • LOCATION : emplacement de l'ensemble de données parent du magasin DICOM
  • DESTINATION_BUCKET/DIRECTORY : bucket Cloud Storage de destination.
  • BUCKET/DIRECTORY/FILTER_FILE : emplacement du fichier de filtre dans un bucket Cloud Storage

Le résultat est le suivant :

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

Pour afficher l'état de l'opération, exécutez la commande gcloud healthcare operations describe et spécifiez la valeur OPERATION_ID de la réponse :

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

Remplacez les éléments suivants :

  • OPERATION_ID : numéro d'ID renvoyé par la réponse précédente
  • DATASET_ID : nom de l'ensemble de données parent du magasin DICOM
  • LOCATION : emplacement de l'ensemble de données parent du magasin DICOM

Le résultat est le suivant :

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

Pour exporter des données DICOM à l'aide d'un filtre, utilisez la méthode projects.locations.datasets.dicomStores.export.

curl

Pour exporter des données DICOM à l'aide d'un fichier de filtre, envoyez une requête POST et fournissez les informations suivantes :

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination
  • L'emplacement du fichier de filtre dans un bucket Cloud Storage

L'exemple suivant montre une requête POST utilisant 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"

Si la requête aboutit, le serveur affiche la réponse suivante au format JSON :

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

La réponse contient un nom d'opération. Utilisez la méthode get pour suivre l'état de l'opération :

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"

Si la requête aboutit, le serveur affiche la réponse suivante au format 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

Pour exporter des données DICOM à l'aide d'un fichier de filtre, envoyez une requête POST et fournissez les informations suivantes :

  • Nom et emplacement de l'ensemble de données parent
  • Le nom du magasin DICOM
  • Le bucket Cloud Storage de destination
  • L'emplacement du fichier de filtre dans un bucket Cloud Storage

L'exemple suivant montre une requête POST utilisant 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

Si la requête aboutit, le serveur affiche la réponse suivante au format JSON :

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

La réponse contient un nom d'opération. Utilisez la méthode get pour suivre l'état de l'opération :

$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

Si la requête aboutit, le serveur affiche la réponse suivante avec l'état de l'opération au format 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": "..."
  }
}

Résoudre les problèmes liés aux requêtes d'exportation DICOM

Si des erreurs se produisent lors d'une requête d'exportation DICOM, elles sont consignées dans Cloud Logging. Pour en savoir plus, consultez la section Afficher les journaux d'erreurs dans Cloud Logging.

Si l'ensemble de l'opération renvoie une erreur, consultez la section Résoudre les problèmes d'opérations de longue durée.