Importar y exportar datos de DICOM con Cloud Storage

En esta página, se explica cómo exportar instancias de DICOM y cómo importar objetos de DICOM desde Cloud Storage. Una instancia de DICOM suele ser una imagen, pero puede ser otro tipo de datos persistentes, como un informe estructurado. Un objeto DICOM en Cloud Storage es una instancia de DICOM que reside en Cloud Storage. Para obtener más información, consulta Cloud Storage.

Configura permisos de Cloud Storage

Antes de importar y exportar datos de DICOM desde y hacia Cloud Storage, debes otorgar permisos adicionales a la cuenta de servicio del agente de servicios de Cloud Healthcare. Para obtener más información, consulta Permisos de Cloud Storage de la tienda de DICOM.

Importa objetos de DICOM

Para importar varios archivos de instancias de DICOM a un almacén de DICOM, puedes usar cualquiera de los siguientes métodos:

En las siguientes muestras, se demuestra cómo importar objetos de DICOM desde un bucket de Cloud Storage.

Console

Para importar objetos de DICOM desde un bucket de Cloud Storage, completa los siguientes pasos:

  1. En la consola de Google Cloud, ve a la página Conjuntos de datos.
    Ir a Conjuntos de datos
  2. Haz clic en el conjunto de datos que contiene el almacén de DICOM al que importas los objetos de DICOM.
  3. En la lista de almacenes de datos, selecciona Importar en la lista Acciones para el almacén de DICOM.

    Aparecerá la página Importa al almacén de DICOM.
  4. En la lista Proyecto, selecciona un proyecto de Cloud Storage.
  5. En la lista Ubicación, selecciona un bucket de Cloud Storage.
  6. Si deseas establecer una ubicación específica para la importación de archivos, haz lo siguiente:
    1. Expande Opciones avanzadas.
    2. Selecciona Anular ruta de Cloud Storage.
    3. Si quieres establecer una fuente específica para importar archivos, define la ruta de acceso con las siguientes variables en el cuadro de texto Ubicación:
      • *: hace coincidir caracteres sin separadores.
      • **: hace coincidir caracteres, incluidos los separadores. Se puede usar con una extensión de nombre de archivo para hacer coincidir todos los archivos del mismo tipo.
      • ?: hace coincidir 1 carácter.
  7. Haz clic en Importar para importar objetos de DICOM desde la fuente definida.
  8. Para seguir el estado de la operación, haz clic en la pestaña Operaciones. Una vez que se completa la operación, aparecerán las siguientes indicaciones:
    • La sección Estado de la operación de larga duración tiene una marca de verificación verde debajo del encabezado Aceptar.
    • La sección Descripción general tiene una marca de verificación verde y un indicador Aceptar en la misma fila que el ID de la operación.
    Si encuentras algún error, haz clic en Acciones y, luego, en Ver detalles en Cloud Logging.

gcloud

Para importar objetos de DICOM desde un bucket de Cloud Storage, usa el comando gcloud healthcare dicom-stores import gcs. Especifica el nombre del conjunto de datos superior, el nombre de la tienda de DICOM y la ubicación del objeto en un bucket de Cloud Storage.

  • La ubicación de los archivos dentro del bucket es arbitraria y no necesita adherirse exactamente al formato especificado en el siguiente ejemplo.
  • Cuando especificas la ubicación de los objetos de DICOM en Cloud Storage, puedes usar comodines para importar varios archivos desde uno o más directorios. Se admiten los siguientes comodines:
    • Usa * para hacer coincidir 0 o más caracteres sin separadores. Por ejemplo, gs://BUCKET/DIRECTORY/Example*.dcm hace coincidir Example.dcm y Example22.dcm en DIRECTORY.
    • Usa ** para hacer coincidir 0 o más caracteres (con separadores). Se debe usar al final de una ruta y no debe haber otros comodines en la ruta. También se puede usar con una extensión de nombre de archivo (como .dcm), que importa todos los archivos con la extensión de nombre de archivo en el directorio especificado y en sus subdirectorios. Por ejemplo, gs://BUCKET/DIRECTORY/**.dcm importa todos los archivos con la extensión de nombre de archivo .dcm en DIRECTORY y en sus subdirectorios.
    • Usa ? para hacer coincidir 1 carácter. Por ejemplo, gs://BUCKET/DIRECTORY/Example?.dcm hace coincidir Example1.dcm, pero no Example.dcm ni Example01.dcm.

En la siguiente muestra, se demuestra cómo importar objetos de DICOM desde un bucket de 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 línea de comandos muestra el ID de la operación:

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

Para ver el estado de la operación, ejecuta el comando gcloud healthcare operations describe y proporciona OPERATION_ID desde la respuesta:

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

Una vez que se completa el comando, se incluirá done: true en la respuesta.

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

Para importar objetos de DICOM desde un depósito de Cloud Storage, usa el método projects.locations.datasets.dicomStores.import.

  • La ubicación de los archivos dentro del bucket puede variar y no tiene que coincidir con el formato especificado en las siguientes muestras.
  • Cuando especificas la ubicación de los objetos de DICOM en Cloud Storage, puedes usar comodines para importar varios archivos desde uno o más directorios. Se admiten los siguientes comodines:
    • Usa * para hacer coincidir 0 o más caracteres sin separadores. Por ejemplo, gs://BUCKET/DIRECTORY/Example*.dcm hace coincidir Example.dcm y Example22.dcm en DIRECTORY.
    • Usa ** para hacer coincidir 0 o más caracteres (con separadores). Se debe usar al final de una ruta y no debe haber otros comodines en la ruta. También se puede usar con una extensión de nombre de archivo (como .dcm), que importa todos los archivos con la extensión de nombre de archivo en el directorio especificado y en sus subdirectorios. Por ejemplo, gs://BUCKET/DIRECTORY/**.dcm importa todos los archivos con la extensión de nombre de archivo .dcm en DIRECTORY y en sus subdirectorios.
    • Usa ? para hacer coincidir 1 carácter. Por ejemplo, gs://BUCKET/DIRECTORY/Example?.dcm hace coincidir Example1.dcm, pero no Example.dcm ni Example01.dcm.

REST

  1. Importarás el objeto DICOM.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • PROJECT_IDEl ID de tu proyecto de Google Cloud.
    • LOCATION: La ubicación del conjunto de datos
    • DATASET_ID: El conjunto de datos superior del almacén de DICOM
    • DICOM_STORE_ID: El ID del almacén de DICOM
    • BUCKET/PATH/TO/FILE: Es la ruta de acceso al objeto de DICOM en Cloud Storage.

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

    Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

    Luego, ejecuta el siguiente comando para enviar tu solicitud de 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
    Este es el resultado. La respuesta contiene un identificador para una operación de larga duración. Las operaciones de larga duración se muestran cuando las llamadas de métodos pueden tardar una cantidad considerable de tiempo en completarse. Toma nota del valor de OPERATION_ID. Necesitarás este valor en el siguiente paso.

  2. Obtén el estado de la operación de larga duración.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • PROJECT_IDEl ID de tu proyecto de Google Cloud.
    • LOCATION: La ubicación del conjunto de datos
    • DATASET_ID: El conjunto de datos superior del almacén de DICOM
    • OPERATION_ID: Es el ID que muestra la operación de larga duración.

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Ejecuta el siguiente comando: 

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

    PowerShell

    Ejecuta el siguiente comando: 

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

    Invoke-WebRequest `
        -Method GET `
        -Headers $headers `
        -Uri "https://healthcare.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content
    Si la operación de larga duración aún está en ejecución, el servidor mostrará una respuesta con la cantidad de instancias de DICOM pendientes de importación. Cuando la LRO finaliza correctamente, el servidor muestra una respuesta con el estado de la operación en formato JSON:

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

Java

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

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

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

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

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

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

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

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

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

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

Node.js

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

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

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

  const operationRequest = {name: operationName};

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

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

  const {data} = operationStatus;

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

importDicomInstance();

Python

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

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

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

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

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

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

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

    return response

Para recuperar una sola instancia o un estudio de un almacén de DICOM, recupera los datos de DICOM con el servicio web de Retrieve Transaction RESTful como se implementa en la API de Cloud Healthcare.

Especifica una clase de almacenamiento para importar objetos DICOM (versión preliminar)

De forma predeterminada, el método projects.locations.datasets.dicomStores.import importa un objeto DICOM a un almacén de DICOM con una clase de almacenamiento estándar. Puedes configurar la clase de almacenamiento cuando importas objetos DICOM desde Cloud Storage. Para obtener más información, consulta Cambia la clase de almacenamiento de DICOM.

En los siguientes ejemplos, se muestra cómo especificar la clase de almacenamiento cuando importas objetos de DICOM desde Cloud Storage.

REST

Usa el método projects.locations.datasets.dicomStores.import.

  1. Importarás el objeto DICOM.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • PROJECT_IDEl ID de tu proyecto de Google Cloud.
    • LOCATION: La ubicación del conjunto de datos
    • DATASET_ID: El conjunto de datos superior del almacén de DICOM
    • DICOM_STORE_ID: El ID del almacén de DICOM
    • BUCKET/PATH/TO/FILE: Es la ruta de acceso al objeto de DICOM en Cloud Storage.
    • STORAGE_CLASS: Es la clase de almacenamiento para el objeto de DICOM en el almacén de DICOM de STANDARD, NEARLINE, COLDLINE y ARCHIVE.

    Cuerpo JSON de la solicitud: 

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

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

    Luego, ejecuta el siguiente comando para enviar tu solicitud de 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

    Guarda el cuerpo de la solicitud en un archivo llamado request.json. Ejecuta el comando siguiente en la terminal para crear o reemplazar este archivo en el directorio actual: 

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

    Luego, ejecuta el siguiente comando para enviar tu solicitud de 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
    Este es el resultado. La respuesta contiene un identificador para una operación de larga duración. Las operaciones de larga duración se muestran cuando las llamadas de métodos pueden tardar una cantidad considerable de tiempo en completarse. Toma nota del valor de OPERATION_ID. Necesitarás este valor en el siguiente paso.

  2. Obtén el estado de la operación de larga duración.

    Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

    • PROJECT_IDEl ID de tu proyecto de Google Cloud.
    • LOCATION: La ubicación del conjunto de datos
    • DATASET_ID: El conjunto de datos superior del almacén de DICOM
    • OPERATION_ID: Es el ID que muestra la operación de larga duración.

    Para enviar tu solicitud, elige una de estas opciones:

    curl

    Ejecuta el siguiente comando: 

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

    PowerShell

    Ejecuta el siguiente comando: 

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

    Invoke-WebRequest `
        -Method GET `
        -Headers $headers `
        -Uri "https://healthcare.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/datasets/DATASET_ID/operations/OPERATION_ID" | Select-Object -Expand Content
    Si la operación de larga duración aún está en ejecución, el servidor mostrará una respuesta con la cantidad de instancias de DICOM pendientes de importación. Cuando la LRO finaliza, el servidor muestra una respuesta con el estado de la operación en formato JSON:

Soluciona problemas de solicitudes de importación de DICOM

Si se producen errores durante una solicitud de importación de DICOM, estos se registrarán en Cloud Logging. Para obtener más información, consulta Visualiza los registros de errores en Cloud Logging.

Exporta instancias de DICOM

En las siguientes muestras, se demuestra cómo exportar instancias de DICOM a un bucket de Cloud Storage. Cuando exportas instancias de DICOM desde una tienda de DICOM, se exportarán todas las instancias de la tienda.

Console

Para exportar instancias de DICOM a Cloud Storage, completa los siguientes pasos:

  1. En la consola de Google Cloud, ve a la página Conjuntos de datos.
    Ir a Conjuntos de datos
  2. Haz clic en el conjunto de datos que contiene el almacén de DICOM desde el que exportas instancias de DICOM.
  3. En la lista de almacenes de datos, selecciona Exportar en la lista Acciones para el almacén de DICOM.
  4. En la página Exportar almacén de DICOM que aparecerá, selecciona bucket de Google Cloud Storage.
  5. En la lista Proyecto, selecciona un proyecto de Cloud Storage.
  6. En la lista Ubicación, selecciona un bucket de Cloud Storage.
  7. En Configuración de exportación de DICOM, selecciona el tipo de archivo que usas para exportar las instancias de DICOM. Estos son los tipos que se encuentran disponibles:
    • Archivo de DICOM (.dcm)
    • octet-stream
    • Imagen (.jpg, .png)
  8. Para definir la sintaxis de transferencia adicional, selecciona la sintaxis en la lista Sintaxis de transferencia.
  9. Haz clic en Exportar para exportar las instancias de DICOM a la ubicación definida en Cloud Storage.
  10. Para seguir el estado de la operación, haz clic en la pestaña Operaciones. Una vez que se completa la operación, aparecerán las siguientes indicaciones:
    • La sección Estado de la operación de larga duración tiene una marca de verificación verde debajo del encabezado Aceptar.
    • La sección Descripción general tiene una marca de verificación verde y un indicador Aceptar en la misma fila que el ID de la operación.
    Si encuentras algún error, haz clic en Acciones y, luego, en Ver detalles en Cloud Logging.

gcloud

Para exportar instancias de DICOM a un depósito de Cloud Storage, usa el comando gcloud healthcare dicom-stores export gcs.

  • Proporciona el nombre del conjunto de datos superior, el nombre de la tienda de DICOM y el bucket de Cloud Storage de destino.
  • Escribe en un depósito o un directorio de Cloud Storage, en lugar de en un objeto, ya que la API de Cloud Healthcare crea un archivo .dcm para cada objeto.
  • Si el comando especifica un directorio que no existe, este se creará.

En el siguiente ejemplo, se muestra el comando gcloud healthcare dicom-stores export gcs.

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

La línea de comandos muestra el ID de la operación:

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

Para ver el estado de la operación, ejecuta el comando gcloud healthcare operations describe y proporciona OPERATION_ID desde la respuesta:

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

Una vez que se completa el comando, se incluirá done: true en la respuesta.

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

Para exportar instancias de DICOM a un depósito de Cloud Storage, usa el método projects.locations.datasets.dicomStores.export.

  • Escribe en un depósito o un directorio de Cloud Storage, en lugar de en un objeto, ya que la API de Cloud Healthcare crea un archivo .dcm para cada objeto de DICOM.
  • Si el comando especifica un directorio que no existe, este se creará.

curl

Para exportar instancias de DICOM, realiza una solicitud POST y proporciona la siguiente información:

  • El nombre y la ubicación del conjunto de datos superior
  • El nombre del almacén de DICOM
  • El bucket de destino de Cloud Storage

En el siguiente ejemplo, se muestra una solicitud POST mediante 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 solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

La respuesta contiene un nombre de operación. Para realizar un seguimiento del estado de la operación, usa el método get de la operación:

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 solicitud es exitosa, el servidor mostrará una respuesta con el estado de la operación en formato JSON:

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

PowerShell

Para exportar instancias de DICOM, realiza una solicitud POST y proporciona la siguiente información:

  • El nombre y la ubicación del conjunto de datos superior
  • El nombre del almacén de DICOM
  • El bucket de destino de Cloud Storage

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell.

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

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

Si la solicitud tiene éxito, se mostrará la respuesta en formato JSON en el servidor:

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

La respuesta contiene un nombre de operación. Para realizar un seguimiento del estado de la operación, usa el método get de la operación:

$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 solicitud es exitosa, el servidor mostrará una respuesta con el estado de la operación en formato JSON:

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

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

Java

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

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

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

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

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

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

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

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

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

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

Node.js

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

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

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

exportDicomInstanceGcs();

Python

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

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

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

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

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

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

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

    return response

Exporta instancias de DICOM mediante filtros

De forma predeterminada, cuando exportas archivos de DICOM a Cloud Storage, se exportan todos los archivos de DICOM en el almacén de DICOM. De manera similar, cuando exportas metadatos de DICOM a BigQuery, se exportan los metadatos de todos los datos de DICOM en el almacén de DICOM.

Puedes exportar un subconjunto de datos o metadatos de DICOM mediante un archivo de filtro.

Configura un archivo de filtro

Con un archivo de filtro, puedes definir la lista de archivos de DICOM para exportar a Cloud Storage o BigQuery.

Cada línea del archivo de filtro define el estudio, la serie o la instancia y usa el formato /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID/instances/INSTANCE_UID.

Puedes truncar una línea para especificar el nivel en el que funciona el filtro. Por ejemplo, puedes exportar un estudio completo si especificas /studies/STUDY_INSTANCE_UID o puedes exportar una serie completa si especificas /studies/STUDY_INSTANCE_UID/series/SERIES_INSTANCE_UID.

Considera el siguiente archivo de filtro:

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

Este archivo de filtro genera filtrar lo siguiente:

  • El estudio completo con el UID de la instancia del estudio como 1.123.456.789
  • Dos series separadas con UIDs de instancia de serie como 123.456 y 567.890 en el estudio 1.666.333.111
  • Tres instancias individuales con IDs de instancia, como 111, 222 y 333 en el estudio 1.888.999.222 y la serie 123.456

Crea un archivo de filtro con BigQuery

Para crear un archivo de filtro con BigQuery, debes exportar los metadatos de tu almacén de DICOM a BigQuery. Los metadatos exportados te muestran los UIDs de estudio, serie y, también, instancias de los datos de DICOM en tu almacén de DICOM.

Después de exportar, completa los siguientes pasos:

  1. Realiza consultas para los UIDs de estudio, de serie y de instancia necesarios.

    Por ejemplo, después de exportar metadatos de DICOM a BigQuery, ejecuta la siguiente consulta para concatenar los UIDs de estudio, de serie y de instancia para que coincidan con los requisitos de formato de archivo de filtro:

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

  2. Opcional: Si la consulta muestra un conjunto de resultados grande que excede el tamaño máximo de respuesta, guarda los resultados de la consulta en una tabla de destino nueva en BigQuery.

  3. Guarda los resultados de las consultas en un archivo y expórtalo a Cloud Storage. Si guardaste los resultados de tu consulta en una tabla de destino nueva en el paso 2, consulta Exporta datos de tabla para exportar el contenido de la tabla a Cloud Storage.

  4. Edita el archivo exportado según sea necesario y úsalo como archivo de filtro. Se requiere la ubicación del archivo de filtro en Cloud Storage para la operación de exportación.

Crear un archivo de filtro de forma manual

Para crear un archivo de filtro con contenido personalizado y subirlo a un bucket de Cloud Storage, completa estos pasos:

  1. Crea un archivo de filtro que contenga una lista de instancias cuya clase de almacenamiento deba cambiarse en tu máquina local. Usa el formato que se describe en la sección Configura un archivo de filtro.

  2. Subir el archivo de texto de filtro a una ubicación de Cloud Storage

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

    Reemplaza lo siguiente:

    • PATH_TO_FILTER_FILE: Es la ruta de acceso al archivo de filtro en tu máquina local.
    • FILTER_FILE_NAME: Es el nombre del archivo de filtro.
    • BUCKET/DIRECTORY: Es la ruta de acceso a la ubicación de Cloud Storage.

    Por ejemplo: 

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

Pasa el archivo de filtro

Después de crear un archivo de filtro, llama a la operación de exportación de DICOM y pasar el archivo de filtro con la API de REST. En los siguientes ejemplos, se muestra cómo exportar datos de DICOM con un filtro.

gcloud

Para exportar metadatos de DICOM a Cloud Storage con un filtro, usa el comando 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

Reemplaza lo siguiente:

  • DICOM_STORE_ID: El identificador del almacén de DICOM
  • DATASET_ID: El nombre del conjunto de datos superior del almacén de DICOM
  • LOCATION: La ubicación del conjunto de datos superior del almacén de DICOM
  • DESTINATION_BUCKET/DIRECTORY: El bucket de destino de Cloud Storage
  • BUCKET/DIRECTORY/FILTER_FILE: La ubicación del archivo de filtro en un bucket de Cloud Storage

Este es el resultado:

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

Para ver el estado de la operación, ejecuta el comando gcloud healthcare operations describe y proporciona OPERATION_ID desde la respuesta:

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

Reemplaza lo siguiente:

  • OPERATION_ID: El número de ID que se muestra en la respuesta anterior
  • DATASET_ID: El nombre del conjunto de datos superior del almacén de DICOM
  • LOCATION: La ubicación del conjunto de datos superior del almacén de DICOM

Esta es la salida:

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

Para exportar datos de DICOM con un filtro, usa el método projects.locations.datasets.dicomStores.export.

curl

Para exportar datos de DICOM con un archivo de filtro, realiza una solicitud POST y proporciona la siguiente información:

  • El nombre y la ubicación del conjunto de datos superior
  • El nombre del almacén de DICOM
  • El bucket de destino de Cloud Storage
  • La ubicación del archivo de filtro en un bucket de Cloud Storage

En el siguiente ejemplo, se muestra una solicitud POST mediante 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 solicitud tiene éxito, se mostrará la siguiente respuesta en formato JSON en el servidor:

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

La respuesta contiene un nombre de operación. Usa el método get de operación para realizar un seguimiento del estado de la operación:

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 solicitud se realiza de forma correcta, el servidor muestra la siguiente respuesta en formato JSON:

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

PowerShell

Para exportar datos de DICOM con un archivo de filtro, realiza una solicitud POST y proporciona la siguiente información:

  • El nombre y la ubicación del conjunto de datos superior
  • El nombre del almacén de DICOM
  • El bucket de destino de Cloud Storage
  • La ubicación del archivo de filtro en un bucket de Cloud Storage

En el siguiente ejemplo, se muestra una solicitud POST mediante Windows PowerShell.

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

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

Si la solicitud tiene éxito, se mostrará la siguiente respuesta en formato JSON en el servidor:

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

La respuesta contiene un nombre de operación. Usa el método get de operación para realizar un seguimiento del estado de la operación:

$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 solicitud se realiza de forma correcta, el servidor muestra la siguiente respuesta con el estado de la operación en formato JSON:

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

Soluciona problemas de solicitudes de exportación de DICOM

Si se producen errores durante una solicitud de exportación de DICOM, estos se registrarán en Cloud Logging. Para obtener más información, consulta Visualiza los registros de errores en Cloud Logging.

Si toda la operación muestra un error, consulta Solución de problemas de operaciones de larga duración.