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 il peut s'agir d'un autre type de données persistantes, tel qu'un rapport structuré. Un objet DICOM dans Cloud Storage est une instance DICOM qui réside dans 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 utiliser 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 ne doit pas nécessairement 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, 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, 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 indiquant 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 une seule étude à partir d'un magasin DICOM, récupérez des données DICOM à l'aide du service Web RESTful Retrieve Transaction, tel qu'il est implémenté 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 dans un magasin DICOM avec une classe de stockage standard. Vous pouvez définir la classe de stockage lorsque vous importez des objets DICOM à partir de Cloud Storage. Pour en savoir plus, consultez la section Modifier la classe de stockage DICOM.

Les exemples suivants montrent comment spécifier la classe de stockage lorsque vous importez des 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, 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 store 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, 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 indiquant 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 store DICOM sont exportés. De même, lorsque vous exportez des métadonnées DICOM vers BigQuery, les métadonnées de toutes les données DICOM du store DICOM sont exportées.

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

À l'aide d'un fichier de filtre, vous pouvez définir la liste des fichiers DICOM à exporter vers Cloud Storage ou BigQuery.

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 exporter une étude entière en spécifiant /studies/STUDY_INSTANCE_UID ou une série entière en spécifiant /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID.

Examinez le 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

Ce fichier de filtre permet de filtrer les éléments suivants:

  • L'étude entière avec l'UID de l'instance d'étude en tant que 1.123.456.789
  • Deux séries distinctes avec des UID d'instance de série 123.456 et 567.890 dans l'étude 1.666.333.111
  • Trois instances individuelles avec des ID d'instance tels que 111, 222 et 333 dans l'étude 1.888.999.222 et la 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 exporter les métadonnées de votre magasin DICOM vers BigQuery. Les métadonnées exportées vous indiquent les UID d'étude, de série et d'instance des données DICOM dans votre magasin DICOM.

Une fois l'exportation terminée, procédez comme suit:

  1. Interrogez les UID d'étude, de série et d'instance requis.

    Par exemple, après avoir exporté les métadonnées DICOM vers BigQuery, exécutez la requête suivante pour concaténer les UID d'étude, de série et d'instance afin qu'elles correspondent aux exigences du format de fichier de filtre:

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

  2. Facultatif: si la requête renvoie un ensemble de résultats volumineux qui dépasse la taille maximale de réponse, 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 dans un fichier et exportez-le vers Cloud Storage. Si vous avez enregistré les résultats de votre requête dans une nouvelle table de destination à l'étape 2, consultez la section Exporter les données de table pour exporter le contenu de la table vers Cloud Storage.

  4. Modifiez le fichier exporté si nécessaire et utilisez-le comme fichier de filtre. L'emplacement du fichier de filtre dans Cloud Storage est requis lors de l'opération d'exportation.

Créer un fichier de filtre manuellement

Pour créer un fichier de filtre avec du contenu personnalisé et l'importer dans un bucket Cloud Storage, procédez comme suit:

  1. Créez un fichier de filtre contenant la liste des instances dont la classe de stockage doit être modifiée sur votre ordinateur local. Utilisez le format décrit dans la section Configurer le fichier de filtre.

  2. Importez le fichier texte du filtre vers un emplacement Cloud Storage.

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

    Remplacez les éléments suivants :

    • PATH_TO_FILTER_FILE: chemin d'accès au fichier de filtre sur votre ordinateur local
    • FILTER_FILE_NAME: nom du fichier de filtre
    • BUCKET/DIRECTORY: chemin d'accès à l'emplacement Cloud Storage

    Exemple : 

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

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.