Esportare i metadati delle risorse in Cloud Storage

gcloud

gcloud asset export \
    --SCOPE \
    --billing-project=BILLING_PROJECT_ID \
    --asset-types=ASSET_TYPE_1,ASSET_TYPE_2,... \
    --content-type=CONTENT_TYPE \
    --relationship-types=RELATIONSHIP_TYPE_1,RELATIONSHIP_TYPE_2,... \
    --snapshot-time="SNAPSHOT_TIME" \
    --OUTPUT_TYPE

Fornisci i seguenti valori:

• SCOPE: utilizza uno dei seguenti valori:

  • project=PROJECT_ID, dove PROJECT_ID è l'ID del progetto che contiene i metadati delle risorse che vuoi esportare.

  • folder=FOLDER_ID, dove FOLDER_ID è l'ID della cartella che contiene i metadati delle risorse che vuoi esportare.

    Come trovare l'ID di una Google Cloud cartella

    ConsoleGoogle Cloud

    Per trovare l'ID di una Google Cloud cartella:

    1. Vai alla Google Cloud console.

       Vai alla Google Cloud console

    2. Fai clic sulla casella di elenco selettore nella barra dei menu.
    3. Seleziona la tua organizzazione dalla casella di elenco.
    4. Cerca il nome della cartella. L'ID cartella viene visualizzato accanto al nome della cartella.

    Interfaccia a riga di comando gcloud

    Puoi recuperare l'ID di una cartella Google Cloud che si trova a livello di organizzazione con il seguente comando:

    gcloud resource-manager folders list \
        --organization=$(gcloud organizations describe ORGANIZATION_NAME \
          --format="value(name.segment(1))") \
        --filter='"DISPLAY_NAME":"TOP_LEVEL_FOLDER_NAME"' \
        --format="value(ID)"

    dove TOP_LEVEL_FOLDER_NAME è una corrispondenza parziale o completa della stringa per il nome della cartella. Rimuovi il flag --format per visualizzare ulteriori informazioni sulle cartelle trovate.

    Il comando precedente non restituisce gli ID delle sottocartelle all'interno delle cartelle. Per farlo, esegui il comando seguente utilizzando l'ID di una cartella di primo livello:

    gcloud resource-manager folders list --folder=FOLDER_ID

  • organization=ORGANIZATION_ID, dove ORGANIZATION_ID è l'ID dell'organizzazione che contiene i metadati della risorsa che vuoi esportare.

    Come trovare l'ID di un' Google Cloud organizzazione

    ConsoleGoogle Cloud

    Per trovare l'ID di un' Google Cloud organizzazione:

    1. Vai alla Google Cloud console.

       Vai alla Google Cloud console

    2. Fai clic sulla casella di elenco selettore nella barra dei menu.
    3. Seleziona la tua organizzazione dalla casella di elenco.
    4. Fai clic sulla scheda Tutti. L'ID organizzazione viene visualizzato accanto al nome dell'organizzazione.

    Interfaccia a riga di comando gcloud

    Puoi recuperare l'ID di un'organizzazione Google Cloud con il seguente comando:

    gcloud organizations describe ORGANIZATION_NAME --format="value(name.segment(1))"

• BILLING_PROJECT_ID: (Facoltativo). L'ID progetto in cui si trova l'agente di servizio Cloud Asset Inventory predefinito che dispone delle autorizzazioni per gestire i set di dati e le tabelle BigQuery. Scopri di più sull'impostazione del progetto di fatturazione.

• ASSET_TYPE_#: (Facoltativo). Un elenco separato da virgole di tipi di asset ricercabili. Sono supportate le espressioni regolari compatibili con RE2. Se l'espressione regolare non corrisponde a nessun tipo di asset supportato, viene restituito un errore INVALID_ARGUMENT. Quando --asset-types non è specificato, vengono restituiti tutti i tipi di asset.
• CONTENT_TYPE: (Facoltativo). Il tipo di contenuti dei metadati che vuoi recuperare. Quando --content-type non è specificato, vengono restituite solo informazioni di base, come i nomi degli asset, l'ultima volta che gli asset sono stati aggiornati e i progetti, le cartelle e le organizzazioni a cui appartengono.
• RELATIONSHIP_TYPE_#: (Facoltativo). Richiede l'accesso al livello Premium o Enterprise di Security Command Center o a Gemini Cloud Assist. Un elenco separato da virgole di tipi di relazione tra asset che vuoi recuperare. Affinché questa operazione funzioni, devi impostare CONTENT_TYPE su RELATIONSHIP.
• SNAPSHOT_TIME: (Facoltativo). L'ora in cui vuoi acquisire uno snapshot dei tuoi asset, nel formato data e ora dell'argomento gcloud. Il valore non deve essere precedente a 35 giorni. Quando --snapshot-time non è specificato, viene creato uno snapshot all'ora corrente.

• OUTPUT_TYPE: utilizza uno dei seguenti valori:

  • --output-path="gs://BUCKET_NAME/FILE_NAME" per scrivere l'output in un file, dove:

    • BUCKET_NAME è il nome del bucket Cloud Storage in cui scrivere.
    • FILE_NAME è il file in cui scrivere nel tuo bucket Cloud Storage.

  • --output-path-prefix="gs://BUCKET_NAME/FOLDER_NAME" per scrivere l'output in una cartella, dove:

    • BUCKET_NAME è il nome del bucket Cloud Storage in cui scrivere.
    • FOLDER_NAME è la cartella in cui scrivere nel tuo bucket Cloud Storage. L'output è suddiviso in sottocartelle denominate in base ai tipi di asset. Le sottocartelle non devono già esistere nella cartella specificata.

Per tutte le opzioni, consulta il riferimento gcloud CLI.

Esempio

Esegui il comando seguente per esportare i metadati di resource così com'erano il 30 gennaio 2024 nel progetto my-project nel file my-file.txt nelbucket Cloud Storagege my-bucket.

gcloud asset export \
    --project=my-project \
    --billing-project=my-project \
    --content-type=resource \
    --snapshot-time="2024-01-30" \
    --output-path="gs://my-bucket/my-file.txt"

Esempio di risposta

Export in progress for root asset [projects/my-project].
Use [gcloud asset operations describe projects/000000000000/operations/ExportAssets/RESOURCE/00000000000000000000000000000000] to check the status of the operation.

REST

Metodo HTTP e URL:

POST https://cloudasset.googleapis.com/v1/SCOPE_PATH:exportAssets

Intestazioni:

X-Goog-User-Project: BILLING_PROJECT_ID

Corpo JSON della richiesta:

{
  "assetTypes": [
    "ASSET_TYPE_1",
    "ASSET_TYPE_2",
    "..."
  ],
  "contentType": "CONTENT_TYPE",
  "relationshipTypes": [
    "RELATIONSHIP_TYPE_1",
    "RELATIONSHIP_TYPE_2",
    "..."
  ],
  "readTime": "SNAPSHOT_TIME",
  "outputConfig": {
    "gcsDestination": {
      OUTPUT_TYPE
    }
  }
}

Fornisci i seguenti valori:

• SCOPE_PATH: utilizza uno dei seguenti valori:

  I valori consentiti sono:

  • projects/PROJECT_ID, dove PROJECT_ID è l'ID del progetto che contiene i metadati delle risorse che vuoi esportare.

  • projects/PROJECT_NUMBER, dove PROJECT_NUMBER è il numero del progetto che contiene i metadati dell'asset che vuoi esportare.

    Come trovare un Google Cloud numero di progetto

    ConsoleGoogle Cloud

    Per trovare un numero di progetto, completa i seguenti passaggi: Google Cloud

    1. Vai alla pagina Benvenuto nella console Google Cloud .

       Vai a Benvenuto

    2. Fai clic sulla casella di elenco selettore nella barra dei menu.

    3. Seleziona la tua organizzazione dalla casella di elenco, quindi cerca il nome del tuo progetto. Il nome, il numero e l'ID progetto vengono visualizzati vicino all'intestazione Benvenuto.

       Vengono visualizzate fino a 4000 risorse. Se non vedi il progetto che stai cercando, vai alla pagina Gestisci risorse e filtra l'elenco utilizzando il nome del progetto.

    Interfaccia a riga di comando gcloud

    Puoi recuperare un Google Cloud numero di progetto con il seguente comando:

    gcloud projects describe PROJECT_ID --format="value(projectNumber)"

  • folders/FOLDER_ID, dove FOLDER_ID è l'ID della cartella che contiene i metadati delle risorse che vuoi esportare.

    Come trovare l'ID di una Google Cloud cartella

    ConsoleGoogle Cloud

    Per trovare l'ID di una Google Cloud cartella:

    1. Vai alla Google Cloud console.

       Vai alla Google Cloud console

    2. Fai clic sulla casella di elenco selettore nella barra dei menu.
    3. Seleziona la tua organizzazione dalla casella di elenco.
    4. Cerca il nome della cartella. L'ID cartella viene visualizzato accanto al nome della cartella.

    Interfaccia a riga di comando gcloud

    Puoi recuperare l'ID di una cartella Google Cloud che si trova a livello di organizzazione con il seguente comando:

    gcloud resource-manager folders list \
        --organization=$(gcloud organizations describe ORGANIZATION_NAME \
          --format="value(name.segment(1))") \
        --filter='"DISPLAY_NAME":"TOP_LEVEL_FOLDER_NAME"' \
        --format="value(ID)"

    dove TOP_LEVEL_FOLDER_NAME è una corrispondenza parziale o completa della stringa per il nome della cartella. Rimuovi il flag --format per visualizzare ulteriori informazioni sulle cartelle trovate.

    Il comando precedente non restituisce gli ID delle sottocartelle all'interno delle cartelle. Per farlo, esegui il comando seguente utilizzando l'ID di una cartella di primo livello:

    gcloud resource-manager folders list --folder=FOLDER_ID

  • organizations/ORGANIZATION_ID, dove ORGANIZATION_ID è l'ID dell'organizzazione che contiene i metadati della risorsa che vuoi esportare.

    Come trovare l'ID di un' Google Cloud organizzazione

    ConsoleGoogle Cloud

    Per trovare l'ID di un' Google Cloud organizzazione:

    1. Vai alla Google Cloud console.

       Vai alla Google Cloud console

    2. Fai clic sulla casella di elenco selettore nella barra dei menu.
    3. Seleziona la tua organizzazione dalla casella di elenco.
    4. Fai clic sulla scheda Tutti. L'ID organizzazione viene visualizzato accanto al nome dell'organizzazione.

    Interfaccia a riga di comando gcloud

    Puoi recuperare l'ID di un'organizzazione Google Cloud con il seguente comando:

    gcloud organizations describe ORGANIZATION_NAME --format="value(name.segment(1))"

• BILLING_PROJECT_ID: l'ID progetto in cui si trova l'agente di servizio Cloud Asset Inventory predefinito che dispone delle autorizzazioni per gestire i tuoi set di dati e tabelle BigQuery. Scopri di più sull'impostazione del progetto di fatturazione.

• ASSET_TYPE_#: (Facoltativo). Un array di tipi di asset ricercabili. Sono supportate le espressioni regolari compatibili con RE2. Se l'espressione regolare non corrisponde a nessun tipo di asset supportato, viene restituito un errore INVALID_ARGUMENT. Quando assetTypes non è specificato, vengono restituiti tutti i tipi di asset.
• CONTENT_TYPE: (Facoltativo). Il tipo di contenuti dei metadati che vuoi recuperare. Quando contentType non è specificato, vengono restituite solo informazioni di base, come i nomi degli asset, l'ultima volta che sono stati aggiornati e i progetti, le cartelle e le organizzazioni a cui appartengono.
• RELATIONSHIP_TYPE_#: (Facoltativo). Richiede l'accesso al livello Premium o Enterprise di Security Command Center o a Gemini Cloud Assist. Un elenco separato da virgole di tipi di relazione tra asset che vuoi recuperare. Affinché questa operazione funzioni, devi impostare CONTENT_TYPE su RELATIONSHIP.
• SNAPSHOT_TIME: (Facoltativo). L'ora in cui vuoi acquisire uno snapshot dei tuoi asset, in formato RFC 3339. Il valore non deve essere precedente a 35 giorni. Se readTime non è specificato, viene creato uno snapshot all'ora corrente.

• OUTPUT_TYPE: utilizza uno dei seguenti valori:

  • "uri": "gs://BUCKET_NAME/FILE_NAME" per scrivere l'output in un file, dove:

    • BUCKET_NAME è il nome del bucket Cloud Storage in cui scrivere.
    • FILE_NAME è il file in cui scrivere nel tuo bucket Cloud Storage.

  • "uriPrefix": "gs://BUCKET_NAME/FOLDER_NAME" per scrivere l'output in una cartella, dove:

    • BUCKET_NAME è il nome del bucket Cloud Storage in cui scrivere.
    • FOLDER_NAME è la cartella in cui scrivere nel tuo bucket Cloud Storage. L'output è suddiviso in sottocartelle denominate in base ai tipi di asset. Le sottocartelle non devono già esistere nella cartella specificata.

Consulta il riferimento REST per tutte le opzioni.

Esempi di comandi

Esegui uno dei seguenti comandi per esportare i metadati di resource così com'erano il 30 gennaio 2024 nel progetto my-project, nel file my-file.txt nel bucket Cloud Storage my-bucket.

curl -X POST \
     -H "X-Goog-User-Project: BILLING_PROJECT_ID" \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d '{
            "contentType": "RESOURCE",
            "readTime": "2024-01-30T00:00:00Z",
            "outputConfig": {
              "gcsDestination": {
                "uri": "gs://my-bucket/my-file"
              }
            }
          }' \
     https://cloudasset.googleapis.com/v1/projects/my-project:exportAssets

$cred = gcloud auth print-access-token

$headers = @{ 
  "X-Goog-User-Project" = "BILLING_PROJECT_ID";
  "Authorization" = "Bearer $cred"
}


$body = @"
{
  "contentType": "RESOURCE",
  "readTime": "2024-01-30T00:00:00Z",
  "outputConfig": {
    "gcsDestination": {
      "uri": "gs://my-bucket/my-file"
    }
  }
}
"@

Invoke-WebRequest `
  -Method POST `
  -Headers $headers `
  -ContentType: "application/json; charset=utf-8" `
  -Body $body `
  -Uri "https://cloudasset.googleapis.com/v1/projects/my-project:exportAssets" | Select-Object -Expand Content

Esempio di risposta

{
  "name": "projects/000000000000/operations/ExportAssets/RESOURCE/00000000000000000000000000000000",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.asset.v1.ExportAssetsRequest",
    "parent": "projects/000000000000",
    "readTime": "2024-01-30T00:00:00Z",
    "contentType": "RESOURCE",
    "outputConfig": {
      "gcsDestination": {
        "uri": "gs://my-bucket/export.txt"
      }
    }
  }
}

C#

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Asset.V1;

public class ExportAssetsSample
{
    public ExportAssetsResponse ExportAssets(string bucketName, string projectId)
    {
        string assetDumpFile = $"gs://{bucketName}/my-assets.txt";
        // Create the client
        AssetServiceClient client = AssetServiceClient.Create();
        // Build the request
        ExportAssetsRequest request = new ExportAssetsRequest
        {
            ParentAsResourceName = ProjectName.FromProject(projectId),
            OutputConfig = new OutputConfig
            {
                GcsDestination = new GcsDestination { Uri = assetDumpFile }
            }
        };
        // Start the long-running export operation
        var operation = client.ExportAssets(request);
        // Wait for it to complete (or fail)
        operation = operation.PollUntilCompleted();
        // Return the result
        return operation.Result;
    }
}

Vai

// Sample asset-quickstart exports assets to given path.
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	asset "cloud.google.com/go/asset/apiv1"
	"cloud.google.com/go/asset/apiv1/assetpb"
)

func main() {
	ctx := context.Background()
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	client, err := asset.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()
	bucketName := fmt.Sprintf("%s-for-assets", projectID)
	assetDumpFile := fmt.Sprintf("gs://%s/my-assets.txt", bucketName)
	req := &assetpb.ExportAssetsRequest{
		Parent: fmt.Sprintf("projects/%s", projectID),
		OutputConfig: &assetpb.OutputConfig{
			Destination: &assetpb.OutputConfig_GcsDestination{
				GcsDestination: &assetpb.GcsDestination{
					ObjectUri: &assetpb.GcsDestination_Uri{
						Uri: string(assetDumpFile),
					},
				},
			},
		},
	}
	operation, err := client.ExportAssets(ctx, req)
	if err != nil {
		log.Fatal(err)
	}
	response, err := operation.Wait(ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(response)
}

Java

// Imports the Google Cloud client library

import com.google.cloud.ServiceOptions;
import com.google.cloud.asset.v1.AssetServiceClient;
import com.google.cloud.asset.v1.ContentType;
import com.google.cloud.asset.v1.ExportAssetsRequest;
import com.google.cloud.asset.v1.ExportAssetsRequest.Builder;
import com.google.cloud.asset.v1.ExportAssetsResponse;
import com.google.cloud.asset.v1.GcsDestination;
import com.google.cloud.asset.v1.OutputConfig;
import com.google.cloud.asset.v1.ProjectName;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportAssetsExample {

  // Use the default project Id.
  private static final String projectId = ServiceOptions.getDefaultProjectId();

  /**
   * Export assets for a project.
   *
   * @param exportPath where the results will be exported to
   * @param contentType determines the schema for the table
   * @param assetTypes a list of asset types to export. if empty, export all.
   */
  public static void exportAssets(String exportPath, ContentType contentType, String[] assetTypes)
      throws IOException,
          IllegalArgumentException,
          InterruptedException,
          ExecutionException,
          TimeoutException {
    try (AssetServiceClient client = AssetServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      OutputConfig outputConfig =
          OutputConfig.newBuilder()
              .setGcsDestination(GcsDestination.newBuilder().setUri(exportPath).build())
              .build();
      Builder exportAssetsRequestBuilder =
          ExportAssetsRequest.newBuilder()
              .setParent(parent.toString())
              .setContentType(contentType)
              .setOutputConfig(outputConfig);
      if (assetTypes.length > 0) {
        exportAssetsRequestBuilder.addAllAssetTypes(Arrays.asList(assetTypes));
      }
      ExportAssetsRequest request = exportAssetsRequestBuilder.build();
      ExportAssetsResponse response = client.exportAssetsAsync(request).get(5, TimeUnit.MINUTES);
      System.out.println(response);
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const dumpFilePath = 'gs://my-bucket/my-assets.txt';
// const contentType = 'RESOURCE';

const {AssetServiceClient} = require('@google-cloud/asset');
const client = new AssetServiceClient();

async function exportAssets() {
  const projectId = await client.getProjectId();
  const projectResource = `projects/${projectId}`;

  // TODO(developer): choose the dump file path
  // const dumpFilePath = 'Dump file path, e.g.: gs://<my_bucket>/<my_asset_file>'
  const request = {
    parent: projectResource,
    contentType: contentType,
    outputConfig: {
      gcsDestination: {
        uri: dumpFilePath,
      },
    },
  };

  // Handle the operation using the promise pattern.
  const [operation] = await client.exportAssets(request);

  // Operation#promise starts polling for the completion of the operation.
  const [result] = await operation.promise();

  // Do things with with the response.
  console.log(result);
}
exportAssets().catch(err => {
  throw err;
});

PHP

use Google\Cloud\Asset\V1\Client\AssetServiceClient;
use Google\Cloud\Asset\V1\ExportAssetsRequest;
use Google\Cloud\Asset\V1\GcsDestination;
use Google\Cloud\Asset\V1\OutputConfig;

/**
 * Export assets for given project to specified dump file path.
 *
 * @param string $projectId the project Id for export assets.
 * @param string $dumpFilePath the file path where the assets will be dumped to.
 *        e.g.: gs://[bucket-name]/[asset-file-name].
 */
function export_assets(string $projectId, string $dumpFilePath)
{
    $client = new AssetServiceClient();

    $gcsDestination = new GcsDestination(['uri' => $dumpFilePath]);
    $outputConfig = new OutputConfig(['gcs_destination' => $gcsDestination]);
    $request = (new ExportAssetsRequest())
        ->setParent("projects/$projectId")
        ->setOutputConfig($outputConfig);

    $resp = $client->exportAssets($request);

    $resp->pollUntilComplete();

    if ($resp->operationSucceeded()) {
        print('The result is dumped to $dumpFilePath successfully.' . PHP_EOL);
    } else {
        $error = $resp->getError();
        printf('There was an error: "%s".' . PHP_EOL, $error?->getMessage());
        // handleError($error)
    }
}

Python

from google.cloud import asset_v1

# TODO project_id = 'Your Google Cloud Project ID'
# TODO dump_file_path = 'Your asset dump file path'

client = asset_v1.AssetServiceClient()
parent = f"projects/{project_id}"
output_config = asset_v1.OutputConfig()
output_config.gcs_destination.uri = dump_file_path
request_options = {"parent": parent, "output_config": output_config}

if content_type is not None:
    request_options["content_type"] = content_type

response = client.export_assets(request=request_options)
print(response.result())

Ruby

require "google/cloud/asset"

asset_service = Google::Cloud::Asset.asset_service
# project_id = 'YOUR_PROJECT_ID'
formatted_parent = asset_service.project_path project: project_id
# Assets dump file path, e.g.: gs://[YOUR_BUCKET]/[YOUR_ASSETS_FILE]
# dump_file_path = 'YOUR_ASSET_DUMP_FILE_PATH'
output_config = {
  gcs_destination: {
    uri: dump_file_path
  }
}

operation = asset_service.export_assets(
  parent: formatted_parent, output_config: output_config
) do |op|
  # Handle the error.
  raise op.results.message if op.error?
end

operation.wait_until_done!
response = operation.response
puts "Exported assets to: #{response.output_config.gcs_destination.uri}"
# Do things with the result

gcloud

Per visualizzare lo stato dell'esportazione, completa le seguenti istruzioni:

1. Recupera OPERATION_PATH, che include l'ID operazione, dalla risposta alla richiesta di esportazione. OPERATION_PATH viene mostrato nella risposta all'esportazione, formattata nel seguente modo:

   projects/PROJECT_NUMBER/operations/ExportAssets/CONTENT_TYPE/OPERATION_ID
   

2. Per controllare lo stato dell'esportazione, esegui il seguente comando con OPERATION_PATH:

   gcloud asset operations describe OPERATION_PATH
   

REST

Per visualizzare lo stato dell'esportazione, completa le seguenti istruzioni:

1. Recupera OPERATION_PATH, che include l'ID operazione, dalla risposta alla richiesta di esportazione. Il OPERATION_PATH viene visualizzato come valore del campo name nella risposta all'esportazione, formattato nel seguente modo:

   projects/PROJECT_NUMBER/operations/ExportAssets/CONTENT_TYPE/OPERATION_ID
   

2. Per controllare lo stato dell'esportazione, invia la seguente richiesta.

   REST

   Metodo HTTP e URL:

   GET https://cloudasset.googleapis.com/v1/OPERATION_PATH
   

   Esempi di comandi

   curl (Linux, macOS o Cloud Shell)

   curl -X GET \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        https://cloudasset.googleapis.com/v1/OPERATION_PATH

   PowerShell (Windows)

   $cred = gcloud auth print-access-token
   
   $headers = @{ 
     "Authorization" = "Bearer $cred"
   }
   
   
   Invoke-WebRequest `
     -Method GET `
     -Headers $headers `
     -Uri "https://cloudasset.googleapis.com/v1/OPERATION_PATH" | Select-Object -Expand Content

   Esempio di risposta

   {
     "name": "projects/000000000000/operations/ExportAssets/RESOURCE/00000000000000000000000000000000",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.asset.v1.ExportAssetsRequest",
       "parent": "projects/000000000000",
       "readTime": "2024-01-30T00:00:00Z",
       "contentType": "RESOURCE",
       "outputConfig": {
         "gcsDestination": {
           "uri": "gs://my-bucket/export.txt"
         }
       }
     }
   }