클라우드 애셋 인벤토리 클라이언트 라이브러리

이 페이지에서는 Cloud Asset API용 Cloud 클라이언트 라이브러리를 시작하는 방법을 보여줍니다. Cloud API용 클라이언트 라이브러리 및 이전 Google API 클라이언트 라이브러리에 대한 자세한 내용은 클라이언트 라이브러리 설명을 참조하세요.

클라이언트 라이브러리 설치

C#

자세한 내용은 C# 개발 환경 설정을 참조하세요.

패키지 관리자

Install-Package Google.Cloud.Asset.V1Beta1
.NET CLI
dotnet add package Google.Cloud.Asset.V1Beta1
패킷 CLI
packet add Google.Cloud.Asset.V1Beta1

Go

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

자바

자세한 내용은 자바 개발 환경 설정을 참조하세요. Maven을 사용하는 경우 pom.xml 파일에 다음을 추가합니다.

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

Gradle을 사용하는 경우 종속 항목에 다음을 추가합니다.

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

Node.js

자세한 내용은 Node.js 개발 환경 설정을 참조하세요.
npm install --save @google-cloud/asset

PHP

composer require google/cloud-asset

Python

자세한 내용은 Python 개발 환경 설정을 참조하세요.
pip install --upgrade google-cloud-asset

Ruby

자세한 내용은 Ruby 개발 환경 설정을 참조하세요.
gem install google-cloud-asset

인증 설정

클라이언트 라이브러리를 실행하려면 우선 서비스 계정을 만들고 환경 변수를 설정하여 인증을 설정해야 합니다. 다음 단계에 따라 인증 설정을 완료합니다. 자세한 내용은 GCP 인증 문서를 참조하세요.

GCP Console

  1. GCP Console에서 서비스 계정 키 만들기 페이지로 이동합니다.

    서비스 계정 키 만들기 페이지로 이동
  2. 서비스 계정 목록에서 새 서비스 계정을 선택합니다.
  3. 서비스 계정 이름 필드에 이름을 입력합니다.
  4. 역할 목록에서 프로젝트 > 소유자를 선택합니다.

    참고: 역할 필드가 리소스에 액세스할 수 있도록 서비스 계정을 승인합니다. 나중에 GCP Console을 사용하여 이 필드를 보고 변경할 수 있습니다. 프로덕션 애플리케이션을 개발하는 경우 프로젝트 > 소유자보다 세부적인 권한을 지정합니다. 자세한 내용은 서비스 계정에 역할 부여를 참조하세요.
  5. 만들기를 클릭합니다. 키가 포함된 JSON 파일이 컴퓨터에 다운로드됩니다.

명령줄

로컬 머신 또는 Cloud Shell에서 Cloud SDK를 사용하여 다음 명령어를 실행할 수 있습니다.

  1. 서비스 계정을 만듭니다. [NAME]을 서비스 계정 이름으로 바꿉니다.

    gcloud iam service-accounts create [NAME]
  2. 서비스 계정에 권한을 부여합니다. [PROJECT_ID]를 프로젝트 ID로 바꿉니다.

    gcloud projects add-iam-policy-binding [PROJECT_ID] --member "serviceAccount:[NAME]@[PROJECT_ID].iam.gserviceaccount.com" --role "roles/owner"
    참고: 역할 필드가 리소스에 액세스할 수 있도록 서비스 계정을 승인합니다. 이 필드는 나중에 GCP Console을 사용하여 보고 변경할 수 있습니다. 프로덕션 애플리케이션을 개발하는 경우 프로젝트 > 소유자보다 세부적인 권한을 지정합니다. 자세한 내용은 서비스 계정에 역할 부여를 참조하세요.
  3. 키 파일을 생성합니다. [FILE_NAME]을 키 파일 이름으로 바꿉니다.

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

환경 변수 GOOGLE_APPLICATION_CREDENTIALS를 설정하여 애플리케이션 코드에 사용자 인증 정보를 제공합니다. [PATH]를 서비스 계정 키가 포함된 JSON 파일의 파일 경로로 바꾸고 [FILE_NAME]을 파일 이름으로 바꿉니다. 이 변수는 현재 셸 세션에만 적용되므로 새 세션을 연 경우 변수를 다시 설정합니다.

Linux 또는 macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

예:

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

Windows

PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

예:

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

명령 프롬프트:

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

클라이언트 라이브러리 사용

다음 예에서는 클라이언트 라이브러리를 사용하는 방법을 보여줍니다.

C#

ExportAssets

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Asset.V1Beta1;
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.V1Beta1;
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/v1beta1"
	"golang.org/x/net/context"
	assetpb "google.golang.org/genproto/googleapis/cloud/asset/v1beta1"
)

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/v1beta1"
	"github.com/golang/protobuf/ptypes/timestamp"
	"golang.org/x/net/context"
	assetpb "google.golang.org/genproto/googleapis/cloud/asset/v1beta1"
)

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

자바

ExportAssets

// Imports the Google Cloud client library

import com.google.cloud.ServiceOptions;
import com.google.cloud.asset.v1beta1.AssetServiceClient;
import com.google.cloud.asset.v1beta1.ExportAssetsRequest;
import com.google.cloud.asset.v1beta1.ExportAssetsResponse;
import com.google.cloud.asset.v1beta1.GcsDestination;
import com.google.cloud.asset.v1beta1.OutputConfig;
import com.google.cloud.asset.v1beta1.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.v1beta1.AssetServiceClient;
import com.google.cloud.asset.v1beta1.BatchGetAssetsHistoryRequest;
import com.google.cloud.asset.v1beta1.BatchGetAssetsHistoryResponse;
import com.google.cloud.asset.v1beta1.ContentType;
import com.google.cloud.asset.v1beta1.ProjectName;
import com.google.cloud.asset.v1beta1.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 asset = require('@google-cloud/asset');
const client = new asset.v1beta1.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 asset = require('@google-cloud/asset');
const client = new asset.v1beta1.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\V1beta1\AssetServiceClient;
use Google\Cloud\Asset\V1beta1\GcsDestination;
use Google\Cloud\Asset\V1beta1\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\V1beta1\AssetServiceClient;
use Google\Cloud\Asset\V1beta1\ContentType;
use Google\Cloud\Asset\V1beta1\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_v1beta1
from google.cloud.asset_v1beta1.proto import asset_service_pb2

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

client = asset_v1beta1.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_v1beta1
from google.cloud.asset_v1beta1.proto import assets_pb2
from google.cloud.asset_v1beta1 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_v1beta1.AssetServiceClient()
parent = client.project_path(project_id)
content_type = enums.ContentType.RESOURCE
read_time_window = assets_pb2.TimeWindow()
read_time_window.start_time.GetCurrentTime()
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: :v1beta1)
# 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::V1beta1::AssetServiceClient.project_path(
    project_id
  )
output_config = Google::Cloud::Asset::V1beta1::OutputConfig.new(
  gcs_destination: Google::Cloud::Asset::V1beta1::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::V1beta1::AssetServiceClient.project_path(project_id)

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

asset_service_client = Google::Cloud::Asset.new(version: :v1beta1)
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

추가 자료

이 페이지가 도움이 되었나요? 평가를 부탁드립니다.

다음에 대한 의견 보내기...

Resource Manager