Bibliothèques clientes Cloud Asset Inventory

Cette page montre comment utiliser les bibliothèques clientes Cloud pour l'API Cloud Asset. Pour en savoir plus sur les bibliothèques clientes des API Cloud, y compris les anciennes bibliothèques clientes des API Google, consultez la page Présentation des bibliothèques clientes.

Installer la bibliothèque cliente

C#

Pour en savoir plus, consultez la page Configurer un environnement de développement C#.

Gestionnaire de packages

Install-Package Google.Cloud.Asset.V1
CLI .NET
dotnet add package Google.Cloud.Asset.V1
CLI Paket
packet add Google.Cloud.Asset.V1

Go

go get -u cloud.google.com/go/asset/apiv1

Java

Pour en savoir plus, consultez la section Configurer un environnement de développement Java. Si vous utilisez Maven, ajoutez ce code à votre fichier pom.xml :

<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-asset</artifactId>
    <version>0.86.0-beta</version>
</dependency>

Si vous utilisez Gradle, ajoutez ceci à vos dépendances :

compile group: 'com.google.cloud', name: 'google-cloud-asset', version: '0.86.0-beta'

Node.js

Pour en savoir plus, consultez la section Configurer un environnement de développement Node.js.
npm install --save @google-cloud/asset

PHP

composer require google/cloud-asset

Python

Pour en savoir plus, consultez la section Configurer un environnement de développement Python.
pip install --upgrade google-cloud-asset

Ruby

Pour en savoir plus, consultez la section Configurer un environnement de développement Ruby.
gem install google-cloud-asset

Configurer l'authentification

Pour exécuter la bibliothèque cliente, vous devez d'abord configurer l'authentification en créant un compte de service et en définissant une variable d'environnement. Suivez les étapes ci-dessous pour configurer l'authentification. Pour en savoir plus, consultez la documentation sur l'authentification dans GCP.

Console GCP

  1. Dans la console GCP, accédez à la page Créer une clé de compte de service.

    Accéder à la page "Créer une clé de compte de service"
  2. Dans la liste Compte de service, sélectionnez Nouveau compte de service.
  3. Dans le champ Nom du compte de service, saisissez un nom.
  4. Dans la liste Rôle, sélectionnez Projet > Propriétaire.

    Remarque : Le champ Rôle autorise votre compte de service à accéder aux ressources. Vous pouvez afficher et modifier ce champ ultérieurement à l'aide de la console GCP. Si vous développez une application de production, spécifiez des autorisations plus précises que Projet > Propriétaire. Pour plus d'informations, consultez la page Attribuer des rôles aux comptes de service.
  5. Cliquez sur Créer. Un fichier JSON contenant votre clé est téléchargé sur votre ordinateur.

Ligne de commande

Vous pouvez exécuter les commandes suivantes à l'aide du SDK Cloud sur votre ordinateur local, ou dans Cloud Shell.

  1. Créez le compte de service. Remplacez [NAME] par le nom que vous souhaitez donner au compte de service.

    gcloud iam service-accounts create [NAME]
  2. Accordez des autorisations au compte de service. Remplacez [PROJECT_ID] par votre ID de projet.

    gcloud projects add-iam-policy-binding [PROJECT_ID] --member "serviceAccount:[NAME]@[PROJECT_ID].iam.gserviceaccount.com" --role "roles/owner"
    Remarque : Le champ Rôle autorise votre compte de service à accéder aux ressources. Vous pouvez afficher et modifier le champ ultérieurement à l'aide de la console GCP. Si vous développez une application de production, spécifiez des autorisations plus précises que Projet > Propriétaire. Pour plus d'informations, consultez la page Attribuer des rôles aux comptes de service.
  3. Générez le fichier de clé. Remplacez [FILE_NAME] par le nom du fichier de clé.

    gcloud iam service-accounts keys create [FILE_NAME].json --iam-account [NAME]@[PROJECT_ID].iam.gserviceaccount.com

Fournissez des identifiants d'authentification au code de votre application en définissant la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. Remplacez [PATH] par le chemin du fichier JSON contenant la clé de votre compte de service et [FILE_NAME] par le nom du fichier. Cette variable ne s'applique qu'à la session de shell actuelle. Par conséquent, si vous ouvrez une nouvelle session, vous devez de nouveau la définir.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Exemple :

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/[FILE_NAME].json"

Windows

Avec PowerShell :

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Exemple :

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

Avec l'invite de commande :

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Utiliser la bibliothèque cliente

L'exemple suivant vous montre comment utiliser la bibliothèque cliente.

C#

ExportAssets

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

public class ExportAssets
{
    public static void Main(string[] args)
    {
        string bucketName = "YOUR-BUCKET-NAME";
        string projectId = "YOUR-GOOGLE-PROJECT-ID";
        string assetDumpFile = String.Format("gs://{0}/my-assets.txt", bucketName);
        AssetServiceClient client = AssetServiceClient.Create();
        ExportAssetsRequest request = new ExportAssetsRequest
        {
            ParentAsProjectName = new ProjectName(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();
        // Extract the result
        ExportAssetsResponse response = operation.Result;
        Console.WriteLine(response);
    }
}

BatchGetAssetsHistory

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Asset.V1;
using Google.Protobuf.WellKnownTypes;
using System;

public class BatchGetAssetsHistory
{
    public static void Main(string[] args)
    {
        // Asset names, e.g.: //storage.googleapis.com/[YOUR_BUCKET_NAME]
        string[] assetNames = { "ASSET-NAME" };
        string projectId = "YOUR-GOOGLE-PROJECT-ID";

        BatchGetAssetsHistoryRequest request = new BatchGetAssetsHistoryRequest
        {
            ParentAsProjectName = new ProjectName(projectId),
            ContentType = ContentType.Resource,
            ReadTimeWindow = new TimeWindow
            {
                StartTime = Timestamp.FromDateTime(System.DateTime.UtcNow)
            }
        };
        request.AssetNames.AddRange(assetNames);
        AssetServiceClient client = AssetServiceClient.Create();
        BatchGetAssetsHistoryResponse response = client.BatchGetAssetsHistory(request);
        Console.WriteLine(response);
    }
}

Go

ExportAssets

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

import (
	"fmt"
	"log"
	"os"

	asset "cloud.google.com/go/asset/apiv1"
	"golang.org/x/net/context"
	assetpb "google.golang.org/genproto/googleapis/cloud/asset/v1"
)

func main() {
	ctx := context.Background()
	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	client, err := asset.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}
	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)
}

BatchGetAssetsHistory

// Sample asset-quickstart batch-gets assets history.
package main

import (
	"fmt"
	"log"
	"os"
	"time"

	asset "cloud.google.com/go/asset/apiv1"
	"github.com/golang/protobuf/ptypes/timestamp"
	"golang.org/x/net/context"
	assetpb "google.golang.org/genproto/googleapis/cloud/asset/v1"
)

func main() {
	ctx := context.Background()
	client, err := asset.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}

	projectID := os.Getenv("GOOGLE_CLOUD_PROJECT")
	bucketResourceName := fmt.Sprintf("//storage.googleapis.com/%s-for-assets", projectID)
	req := &assetpb.BatchGetAssetsHistoryRequest{
		Parent:      fmt.Sprintf("projects/%s", projectID),
		AssetNames:  []string{bucketResourceName},
		ContentType: assetpb.ContentType_RESOURCE,
		ReadTimeWindow: &assetpb.TimeWindow{
			StartTime: &timestamp.Timestamp{
				Seconds: time.Now().Unix(),
			},
		},
	}
	response, err := client.BatchGetAssetsHistory(ctx, req)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(response)
}

Java

ExportAssets

// Imports the Google Cloud client library

import com.google.cloud.ServiceOptions;
import com.google.cloud.asset.v1.AssetServiceClient;
import com.google.cloud.asset.v1.ExportAssetsRequest;
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;

public class ExportAssetsExample {

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

  // Export assets for a project.
  // @param args path where the results will be exported to.
  public static void main(String... args) throws Exception {
    // Gcs path, e.g.: "gs://<my_asset_bucket>/<my_asset_dump_file>"
    String exportPath = args[0];
    try (AssetServiceClient client = AssetServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      OutputConfig outputConfig =
          OutputConfig.newBuilder()
              .setGcsDestination(GcsDestination.newBuilder().setUri(exportPath).build())
              .build();
      ExportAssetsRequest request =
          ExportAssetsRequest.newBuilder()
              .setParent(parent.toString())
              .setOutputConfig(outputConfig)
              .build();
      ExportAssetsResponse response = client.exportAssetsAsync(request).get();
      System.out.println(response);
    }
  }
}

BatchGetAssetsHistory

// Imports the Google Cloud client library

import com.google.cloud.ServiceOptions;
import com.google.cloud.asset.v1.AssetServiceClient;
import com.google.cloud.asset.v1.BatchGetAssetsHistoryRequest;
import com.google.cloud.asset.v1.BatchGetAssetsHistoryResponse;
import com.google.cloud.asset.v1.ContentType;
import com.google.cloud.asset.v1.ProjectName;
import com.google.cloud.asset.v1.TimeWindow;
import java.util.Arrays;

public class BatchGetAssetsHistoryExample {

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

  // Export assets for a project.
  // @param args path where the results will be exported to.
  public static void main(String... args) throws Exception {
    // Asset names, e.g.: "//storage.googleapis.com/[BUCKET_NAME]"
    String[] assetNames = args[0].split(",");
    try (AssetServiceClient client = AssetServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      ContentType contentType = ContentType.CONTENT_TYPE_UNSPECIFIED;
      TimeWindow readTimeWindow = TimeWindow.newBuilder().build();
      BatchGetAssetsHistoryRequest request = BatchGetAssetsHistoryRequest.newBuilder()
          .setParent(parent.toString())
          .addAllAssetNames(Arrays.asList(assetNames))
          .setContentType(contentType)
          .setReadTimeWindow(readTimeWindow)
          .build();
      BatchGetAssetsHistoryResponse response = client.batchGetAssetsHistory(request);
      System.out.println(response);
    }
  }
}

Node.js

ExportAssets

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

// Your Google Cloud Platform project ID
const projectId = await client.getProjectId();
const projectResource = client.projectPath(projectId);

// var dumpFilePath = 'Dump file path, e.g.: gs://<my_bucket>/<my_asset_file>'
const outputConfig = {
  gcsDestination: {
    uri: dumpFilePath,
  },
};
const request = {
  parent: projectResource,
  outputConfig: outputConfig,
};

// 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);

BatchGetAssetsHistory

const util = require('util');
const {AssetServiceClient} = require('@google-cloud/asset');
const client = new AssetServiceClient({
  // optional auth parameters.
});

// Your Google Cloud Platform project ID
const projectId = await client.getProjectId();
const projectResource = client.projectPath(projectId);
// Your asset names, such as //storage.googleapis.com/[YOUR_BUCKET_NAME].
// var assetNames = ['ASSET_NAME1', 'ASSET_NAME2', ...];

const contentType = 'RESOURCE';
const readTimeWindow = {
  startTime: {
    seconds: Math.floor(new Date().getTime() / 1000),
  },
};

const request = {
  parent: projectResource,
  assetNames: assetNames,
  contentType: contentType,
  readTimeWindow: readTimeWindow,
};

// Handle the operation using the promise pattern.
const result = await client.batchGetAssetsHistory(request);
// Do things with with the response.
console.log(util.inspect(result, {depth: null}));

PHP

ExportAssets

use Google\Cloud\Asset\V1\AssetServiceClient;
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($projectId, $dumpFilePath)
{
    $client = new AssetServiceClient();

    $gcsDestination = new GcsDestination(['uri' => $dumpFilePath]);
    $outputConfig = new OutputConfig(['gcs_destination' => $gcsDestination]);

    $resp = $client->exportAssets("projects/$projectId", $outputConfig);

    $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)
    }
}

BatchGetAssetsHistory

use Google\Cloud\Asset\V1\AssetServiceClient;
use Google\Cloud\Asset\V1\ContentType;
use Google\Cloud\Asset\V1\TimeWindow;
use Google\Protobuf\Timestamp;

function batch_get_assets_history($projectId, $assetNames)
{
    $client = new AssetServiceClient();
    $formattedParent = $client->projectName($projectId);
    $contentType = ContentType::RESOURCE;
    $readTimeWindow = new TimeWindow(['start_time' => new Timestamp(['seconds' => time()])]);

    $resp = $client->batchGetAssetsHistory($formattedParent, $contentType, $readTimeWindow, ['assetNames' => $assetNames]);

    # Do things with response.
    print($resp->serializeToString());
}

Python

ExportAssets

from google.cloud import asset_v1
from google.cloud.asset_v1.proto import asset_service_pb2

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

client = asset_v1.AssetServiceClient()
parent = client.project_path(project_id)
output_config = asset_service_pb2.OutputConfig()
output_config.gcs_destination.uri = dump_file_path
response = client.export_assets(parent, output_config)
print(response.result())

BatchGetAssetsHistory

from google.cloud import asset_v1
from google.cloud.asset_v1.proto import assets_pb2
from google.cloud.asset_v1 import enums

# TODO project_id = 'Your Google Cloud Project ID'
# TODO asset_names = 'Your asset names list, e.g.:
# ["//storage.googleapis.com/[BUCKET_NAME]",]'

client = asset_v1.AssetServiceClient()
parent = client.project_path(project_id)
content_type = enums.ContentType.RESOURCE
read_time_window = assets_pb2.TimeWindow()
response = client.batch_get_assets_history(
    parent, content_type, read_time_window, asset_names)
print('assets: {}'.format(response.assets))

Ruby

ExportAssets

require "google/cloud/asset"

asset_service_client = Google::Cloud::Asset.new version: :v1
# project_id = 'YOUR_PROJECT_ID'
# Assets dump file path, e.g.: gs://[YOUR_BUCKET]/[YOUR_ASSETS_FILE]
# dump_file_path = 'YOUR_ASSET_DUMP_FILE_PATH'
formatted_parent =
  Google::Cloud::Asset::V1::AssetServiceClient.project_path(
    project_id
  )
output_config = Google::Cloud::Asset::V1::OutputConfig.new(
  gcs_destination: Google::Cloud::Asset::V1::GcsDestination.new(
    uri: dump_file_path
  )
)

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

operation.wait_until_done!
# Do things with the result

BatchGetAssetsHistory

require "google/cloud/asset"

# project_id = 'YOUR_PROJECT_ID'
# asset names, e.g.: //storage.googleapis.com/[YOUR_BUCKET_NAME]
# asset_names = [ASSET_NAMES, COMMMA_DELIMTTED]
formatted_parent =
  Google::Cloud::Asset::V1::AssetServiceClient.project_path project_id

content_type = :RESOURCE
read_time_window = Google::Cloud::Asset::V1::TimeWindow.new(
  start_time: Google::Protobuf::Timestamp.new(seconds: Time.now.getutc.to_i)
)

asset_service_client = Google::Cloud::Asset.new version: :v1
response = asset_service_client.batch_get_assets_history(
  formatted_parent, content_type, read_time_window, asset_names: asset_names
)
# Do things with the response
puts response

Autres ressources

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation de Resource Manager