- 필수 기능
- 시작하기
- Glossary
- 표준 속성
- Guides
- Agent
- 통합
- 개방형텔레메트리
- 개발자
- API
- Datadog Mobile App
- CoScreen
- Cloudcraft
- 앱 내
- 서비스 관리
- 인프라스트럭처
- 애플리케이션 성능
- APM
- Continuous Profiler
- 스팬 시각화
- 데이터 스트림 모니터링
- 데이터 작업 모니터링
- 디지털 경험
- 소프트웨어 제공
- 보안
- AI Observability
- 로그 관리
- 관리
Datadog API를 통해 Datadog-Google Cloud Platform(GCP) 통합을 구성하세요. 자세한 내용은 Datadog-Google Cloud Platform 통합을 참고하세요.
GET https://api.ap1.datadoghq.com/api/v1/integration/gcphttps://api.datadoghq.eu/api/v1/integration/gcphttps://api.ddog-gov.com/api/v1/integration/gcphttps://api.datadoghq.com/api/v1/integration/gcphttps://api.us3.datadoghq.com/api/v1/integration/gcphttps://api.us5.datadoghq.com/api/v1/integration/gcp
This endpoint is deprecated – use the V2 endpoints instead. List all Datadog-GCP integrations configured in your Datadog account.
This endpoint requires the gcp_configuration_read
permission.
OK
Array of GCP account responses.
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"automute": false,
"client_email": "api-dev@datadog-sandbox.iam.gserviceaccount.com",
"client_id": "123456712345671234567",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"cloud_run_revision_filters": [
"$KEY:$VALUE"
],
"errors": [
"*"
],
"host_filters": "key:value,filter:example",
"is_cspm_enabled": true,
"is_resource_change_collection_enabled": true,
"is_security_command_center_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
Bad Request
Error response object.
{
"errors": [
"Bad Request"
]
}
Authentication error
Error response object.
{
"errors": [
"Bad Request"
]
}
Too many requests
Error response object.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X GET "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v1/integration/gcp" \
-H "Accept: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"
"""
List all GCP integrations returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.gcp_integration_api import GCPIntegrationApi
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.list_gcp_integration()
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# List all GCP integrations returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V1::GCPIntegrationAPI.new
p api_instance.list_gcp_integration()
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.gcp_integration_list
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// List all GCP integrations returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)
func main() {
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV1.NewGCPIntegrationApi(apiClient)
resp, r, err := api.ListGCPIntegration(ctx)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.ListGCPIntegration`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.ListGCPIntegration`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// List all GCP integrations returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v1.api.GcpIntegrationApi;
import com.datadog.api.client.v1.model.GCPAccount;
import java.util.List;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
try {
List<GCPAccount> result = apiInstance.listGCPIntegration();
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#listGCPIntegration");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.list()
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python "example.py"
// List all GCP integrations returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV1::api_gcp_integration::GCPIntegrationAPI;
#[tokio::main]
async fn main() {
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.list_gcp_integration().await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* List all GCP integrations returns "OK" response
*/
import { client, v1 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v1.GCPIntegrationApi(configuration);
apiInstance
.listGCPIntegration()
.then((data: v1.GCPAccount[]) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
GET https://api.ap1.datadoghq.com/api/v2/integration/gcp/accountshttps://api.datadoghq.eu/api/v2/integration/gcp/accountshttps://api.ddog-gov.com/api/v2/integration/gcp/accountshttps://api.datadoghq.com/api/v2/integration/gcp/accountshttps://api.us3.datadoghq.com/api/v2/integration/gcp/accountshttps://api.us5.datadoghq.com/api/v2/integration/gcp/accounts
List all GCP STS-enabled service accounts configured in your Datadog account.
This endpoint requires the gcp_configuration_read
permission.
OK
Object containing all your STS enabled accounts.
항목
유형
설명
data
[object]
Array of GCP STS enabled service accounts.
attributes
object
Attributes associated with your service account.
account_tags
[string]
Tags to be associated with GCP metrics and service checks from your account.
automute
boolean
Silence monitors for expected GCE instance shutdowns.
client_email
string
Your service account email address.
cloud_run_revision_filters
[string]
List of filters to limit the Cloud Run revisions that are pulled into Datadog by using tags. Only Cloud Run revision resources that apply to specified filters are imported into Datadog.
host_filters
[string]
Your Host Filters.
is_cspm_enabled
boolean
When enabled, Datadog will activate the Cloud Security Monitoring product for this service account. Note: This requires resource_collection_enabled to be set to true.
is_resource_change_collection_enabled
boolean
When enabled, Datadog scans for all resource change data in your Google Cloud environment.
is_security_command_center_enabled
boolean
When enabled, Datadog will attempt to collect Security Command Center Findings. Note: This requires additional permissions on the service account.
resource_collection_enabled
boolean
When enabled, Datadog scans for all resources in your GCP environment.
id
string
Your service account's unique ID.
meta
object
Additional information related to your service account.
accessible_projects
[string]
The current list of projects accessible from your service account.
type
enum
The type of account.
Allowed enum values: gcp_service_account
default: gcp_service_account
{
"data": [
{
"attributes": {
"account_tags": [],
"automute": false,
"client_email": "datadog-service-account@test-project.iam.gserviceaccount.com",
"cloud_run_revision_filters": [
"$KEY:$VALUE"
],
"host_filters": [],
"is_cspm_enabled": false,
"is_resource_change_collection_enabled": true,
"is_security_command_center_enabled": true,
"resource_collection_enabled": false
},
"id": "d291291f-12c2-22g4-j290-123456678897",
"meta": {
"accessible_projects": []
},
"type": "gcp_service_account"
}
]
}
Not Authorized
API error response.
{
"errors": [
"Bad Request"
]
}
Not Found
API error response.
{
"errors": [
"Bad Request"
]
}
Too many requests
API error response.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X GET "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts" \
-H "Accept: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"
"""
List all GCP STS-enabled service accounts returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.gcp_integration_api import GCPIntegrationApi
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.list_gcpsts_accounts()
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# List all GCP STS-enabled service accounts returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V2::GCPIntegrationAPI.new
p api_instance.list_gcpsts_accounts()
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// List all GCP STS-enabled service accounts returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewGCPIntegrationApi(apiClient)
resp, r, err := api.ListGCPSTSAccounts(ctx)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.ListGCPSTSAccounts`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.ListGCPSTSAccounts`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// List all GCP STS-enabled service accounts returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.GcpIntegrationApi;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountsResponse;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
try {
GCPSTSServiceAccountsResponse result = apiInstance.listGCPSTSAccounts();
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#listGCPSTSAccounts");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
// List all GCP STS-enabled service accounts returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_gcp_integration::GCPIntegrationAPI;
#[tokio::main]
async fn main() {
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.list_gcpsts_accounts().await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* List all GCP STS-enabled service accounts returns "OK" response
*/
import { client, v2 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v2.GCPIntegrationApi(configuration);
apiInstance
.listGCPSTSAccounts()
.then((data: v2.GCPSTSServiceAccountsResponse) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
POST https://api.ap1.datadoghq.com/api/v1/integration/gcphttps://api.datadoghq.eu/api/v1/integration/gcphttps://api.ddog-gov.com/api/v1/integration/gcphttps://api.datadoghq.com/api/v1/integration/gcphttps://api.us3.datadoghq.com/api/v1/integration/gcphttps://api.us5.datadoghq.com/api/v1/integration/gcp
This endpoint is deprecated – use the V2 endpoints instead. Create a Datadog-GCP integration.
This endpoint requires the gcp_configurations_manage
permission.
Create a Datadog-GCP integration.
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"cloud_run_revision_filters": [
"dr:dre"
],
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
OK
{}
Bad Request
Error response object.
{
"errors": [
"Bad Request"
]
}
Authentication error
Error response object.
{
"errors": [
"Bad Request"
]
}
Too many requests
Error response object.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v1/integration/gcp" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"cloud_run_revision_filters": [
"dr:dre"
],
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
EOF
// Create a GCP integration returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)
func main() {
body := datadogV1.GCPAccount{
AuthProviderX509CertUrl: datadog.PtrString("https://www.googleapis.com/oauth2/v1/certs"),
AuthUri: datadog.PtrString("https://accounts.google.com/o/oauth2/auth"),
ClientEmail: datadog.PtrString("252bf553ef04b351@example.com"),
ClientId: datadog.PtrString("163662907116366290710"),
ClientX509CertUrl: datadog.PtrString("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL"),
HostFilters: datadog.PtrString("key:value,filter:example"),
CloudRunRevisionFilters: []string{
"dr:dre",
},
IsCspmEnabled: datadog.PtrBool(true),
IsSecurityCommandCenterEnabled: datadog.PtrBool(true),
PrivateKey: datadog.PtrString("private_key"),
PrivateKeyId: datadog.PtrString("123456789abcdefghi123456789abcdefghijklm"),
ProjectId: datadog.PtrString("datadog-apitest"),
ResourceCollectionEnabled: datadog.PtrBool(true),
TokenUri: datadog.PtrString("https://accounts.google.com/o/oauth2/token"),
Type: datadog.PtrString("service_account"),
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV1.NewGCPIntegrationApi(apiClient)
resp, r, err := api.CreateGCPIntegration(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.CreateGCPIntegration`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.CreateGCPIntegration`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Create a GCP integration returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v1.api.GcpIntegrationApi;
import com.datadog.api.client.v1.model.GCPAccount;
import java.util.Collections;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPAccount body =
new GCPAccount()
.authProviderX509CertUrl("https://www.googleapis.com/oauth2/v1/certs")
.authUri("https://accounts.google.com/o/oauth2/auth")
.clientEmail("252bf553ef04b351@example.com")
.clientId("163662907116366290710")
.clientX509CertUrl("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL")
.hostFilters("key:value,filter:example")
.cloudRunRevisionFilters(Collections.singletonList("dr:dre"))
.isCspmEnabled(true)
.isSecurityCommandCenterEnabled(true)
.privateKey("private_key")
.privateKeyId("123456789abcdefghi123456789abcdefghijklm")
.projectId("datadog-apitest")
.resourceCollectionEnabled(true)
.tokenUri("https://accounts.google.com/o/oauth2/token")
.type("service_account");
try {
apiInstance.createGCPIntegration(body);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#createGCPIntegration");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.create(
type="service_account",
project_id="<GCP_PROJECT_ID>",
private_key_id="<GCP_PRIVATE_KEY_ID>",
private_key="<GCP_PRIVATE_KEY>",
client_email="<GCP_CLIENT_EMAIL>",
client_id="<GCP_CLIENT_ID>",
auth_uri="<GCP_AUTH_URI>",
token_uri="<GCP_TOKEN_URI>",
auth_provider_x509_cert_url="<GCP_AUTH_PROVIDER_X509_CERT_URL>",
client_x509_cert_url="<GCP_CLIENT_X509_CERT_URL>",
host_filters="<KEY>:<VALUE>,<KEY>:<VALUE>"
)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python "example.py"
"""
Create a GCP integration returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v1.model.gcp_account import GCPAccount
body = GCPAccount(
auth_provider_x509_cert_url="https://www.googleapis.com/oauth2/v1/certs",
auth_uri="https://accounts.google.com/o/oauth2/auth",
client_email="252bf553ef04b351@example.com",
client_id="163662907116366290710",
client_x509_cert_url="https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters="key:value,filter:example",
cloud_run_revision_filters=[
"dr:dre",
],
is_cspm_enabled=True,
is_security_command_center_enabled=True,
private_key="private_key",
private_key_id="123456789abcdefghi123456789abcdefghijklm",
project_id="datadog-apitest",
resource_collection_enabled=True,
token_uri="https://accounts.google.com/o/oauth2/token",
type="service_account",
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.create_gcp_integration(body=body)
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
config= {
"type": "service_account",
"project_id": "<GCP_PROJECT_ID>",
"private_key_id": "<PRIVATE_KEY_ID>",
"private_key": "<PRIVATE_KEY>",
"client_email": "<CLIENT_EMAIL>",
"client_id": "<CLIENT_ID>",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://accounts.google.com/o/oauth2/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
dog = Dogapi::Client.new(api_key, app_key)
dog.gcp_integration_create(config)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
# Create a GCP integration returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V1::GCPIntegrationAPI.new
body = DatadogAPIClient::V1::GCPAccount.new({
auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs",
auth_uri: "https://accounts.google.com/o/oauth2/auth",
client_email: "252bf553ef04b351@example.com",
client_id: "163662907116366290710",
client_x509_cert_url: "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters: "key:value,filter:example",
cloud_run_revision_filters: [
"dr:dre",
],
is_cspm_enabled: true,
is_security_command_center_enabled: true,
private_key: "private_key",
private_key_id: "123456789abcdefghi123456789abcdefghijklm",
project_id: "datadog-apitest",
resource_collection_enabled: true,
token_uri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
})
p api_instance.create_gcp_integration(body)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Create a GCP integration returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV1::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV1::model::GCPAccount;
#[tokio::main]
async fn main() {
let body = GCPAccount::new()
.auth_provider_x509_cert_url("https://www.googleapis.com/oauth2/v1/certs".to_string())
.auth_uri("https://accounts.google.com/o/oauth2/auth".to_string())
.client_email("252bf553ef04b351@example.com".to_string())
.client_id("163662907116366290710".to_string())
.client_x509_cert_url(
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL".to_string(),
)
.cloud_run_revision_filters(vec!["dr:dre".to_string()])
.host_filters("key:value,filter:example".to_string())
.is_cspm_enabled(true)
.is_security_command_center_enabled(true)
.private_key("private_key".to_string())
.private_key_id("123456789abcdefghi123456789abcdefghijklm".to_string())
.project_id("datadog-apitest".to_string())
.resource_collection_enabled(true)
.token_uri("https://accounts.google.com/o/oauth2/token".to_string())
.type_("service_account".to_string());
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.create_gcp_integration(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* Create a GCP integration returns "OK" response
*/
import { client, v1 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v1.GCPIntegrationApi(configuration);
const params: v1.GCPIntegrationApiCreateGCPIntegrationRequest = {
body: {
authProviderX509CertUrl: "https://www.googleapis.com/oauth2/v1/certs",
authUri: "https://accounts.google.com/o/oauth2/auth",
clientEmail: "252bf553ef04b351@example.com",
clientId: "163662907116366290710",
clientX509CertUrl:
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
hostFilters: "key:value,filter:example",
cloudRunRevisionFilters: ["dr:dre"],
isCspmEnabled: true,
isSecurityCommandCenterEnabled: true,
privateKey: "private_key",
privateKeyId: "123456789abcdefghi123456789abcdefghijklm",
projectId: "datadog-apitest",
resourceCollectionEnabled: true,
tokenUri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
},
};
apiInstance
.createGCPIntegration(params)
.then((data: any) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
POST https://api.ap1.datadoghq.com/api/v2/integration/gcp/accountshttps://api.datadoghq.eu/api/v2/integration/gcp/accountshttps://api.ddog-gov.com/api/v2/integration/gcp/accountshttps://api.datadoghq.com/api/v2/integration/gcp/accountshttps://api.us3.datadoghq.com/api/v2/integration/gcp/accountshttps://api.us5.datadoghq.com/api/v2/integration/gcp/accounts
Create a new entry within Datadog for your STS enabled service account.
This endpoint requires the gcp_configurations_manage
permission.
항목
유형
설명
data
object
Additional metadata on your generated service account.
attributes
object
Attributes associated with your service account.
account_tags
[string]
Tags to be associated with GCP metrics and service checks from your account.
automute
boolean
Silence monitors for expected GCE instance shutdowns.
client_email
string
Your service account email address.
cloud_run_revision_filters
[string]
List of filters to limit the Cloud Run revisions that are pulled into Datadog by using tags. Only Cloud Run revision resources that apply to specified filters are imported into Datadog.
host_filters
[string]
Your Host Filters.
is_cspm_enabled
boolean
When enabled, Datadog will activate the Cloud Security Monitoring product for this service account. Note: This requires resource_collection_enabled to be set to true.
is_resource_change_collection_enabled
boolean
When enabled, Datadog scans for all resource change data in your Google Cloud environment.
is_security_command_center_enabled
boolean
When enabled, Datadog will attempt to collect Security Command Center Findings. Note: This requires additional permissions on the service account.
resource_collection_enabled
boolean
When enabled, Datadog scans for all resources in your GCP environment.
type
enum
The type of account.
Allowed enum values: gcp_service_account
default: gcp_service_account
{
"data": {
"attributes": {
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
{
"data": {
"attributes": {
"account_tags": [
"lorem",
"ipsum"
],
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
{
"data": {
"attributes": {
"cloud_run_revision_filters": [
"meh:bleh"
],
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
OK
The account creation response.
항목
유형
설명
data
object
Info on your service account.
attributes
object
Attributes associated with your service account.
account_tags
[string]
Tags to be associated with GCP metrics and service checks from your account.
automute
boolean
Silence monitors for expected GCE instance shutdowns.
client_email
string
Your service account email address.
cloud_run_revision_filters
[string]
List of filters to limit the Cloud Run revisions that are pulled into Datadog by using tags. Only Cloud Run revision resources that apply to specified filters are imported into Datadog.
host_filters
[string]
Your Host Filters.
is_cspm_enabled
boolean
When enabled, Datadog will activate the Cloud Security Monitoring product for this service account. Note: This requires resource_collection_enabled to be set to true.
is_resource_change_collection_enabled
boolean
When enabled, Datadog scans for all resource change data in your Google Cloud environment.
is_security_command_center_enabled
boolean
When enabled, Datadog will attempt to collect Security Command Center Findings. Note: This requires additional permissions on the service account.
resource_collection_enabled
boolean
When enabled, Datadog scans for all resources in your GCP environment.
id
string
Your service account's unique ID.
meta
object
Additional information related to your service account.
accessible_projects
[string]
The current list of projects accessible from your service account.
type
enum
The type of account.
Allowed enum values: gcp_service_account
default: gcp_service_account
{
"data": {
"attributes": {
"account_tags": [],
"automute": false,
"client_email": "datadog-service-account@test-project.iam.gserviceaccount.com",
"cloud_run_revision_filters": [
"$KEY:$VALUE"
],
"host_filters": [],
"is_cspm_enabled": false,
"is_resource_change_collection_enabled": true,
"is_security_command_center_enabled": true,
"resource_collection_enabled": false
},
"id": "d291291f-12c2-22g4-j290-123456678897",
"meta": {
"accessible_projects": []
},
"type": "gcp_service_account"
}
}
Bad Request
API error response.
{
"errors": [
"Bad Request"
]
}
Unauthorized
API error response.
{
"errors": [
"Bad Request"
]
}
Not Authorized
API error response.
{
"errors": [
"Bad Request"
]
}
Conflict
API error response.
{
"errors": [
"Bad Request"
]
}
Too many requests
API error response.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"data": {
"attributes": {
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
EOF
# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"data": {
"attributes": {
"account_tags": [
"lorem",
"ipsum"
],
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
EOF
# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"data": {
"attributes": {
"cloud_run_revision_filters": [
"meh:bleh"
],
"client_email": "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
"host_filters": []
},
"type": "gcp_service_account"
}
}
EOF
// Create a new entry for your service account returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
body := datadogV2.GCPSTSServiceAccountCreateRequest{
Data: &datadogV2.GCPSTSServiceAccountData{
Attributes: &datadogV2.GCPSTSServiceAccountAttributes{
ClientEmail: datadog.PtrString("Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"),
HostFilters: []string{},
},
Type: datadogV2.GCPSERVICEACCOUNTTYPE_GCP_SERVICE_ACCOUNT.Ptr(),
},
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewGCPIntegrationApi(apiClient)
resp, r, err := api.CreateGCPSTSAccount(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.CreateGCPSTSAccount`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.CreateGCPSTSAccount`:\n%s\n", responseContent)
}
// Create a new entry for your service account with account_tags returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
body := datadogV2.GCPSTSServiceAccountCreateRequest{
Data: &datadogV2.GCPSTSServiceAccountData{
Attributes: &datadogV2.GCPSTSServiceAccountAttributes{
AccountTags: []string{
"lorem",
"ipsum",
},
ClientEmail: datadog.PtrString("Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"),
HostFilters: []string{},
},
Type: datadogV2.GCPSERVICEACCOUNTTYPE_GCP_SERVICE_ACCOUNT.Ptr(),
},
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewGCPIntegrationApi(apiClient)
resp, r, err := api.CreateGCPSTSAccount(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.CreateGCPSTSAccount`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.CreateGCPSTSAccount`:\n%s\n", responseContent)
}
// Create a new entry for your service account with cloud run revision filters enabled returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
body := datadogV2.GCPSTSServiceAccountCreateRequest{
Data: &datadogV2.GCPSTSServiceAccountData{
Attributes: &datadogV2.GCPSTSServiceAccountAttributes{
CloudRunRevisionFilters: []string{
"meh:bleh",
},
ClientEmail: datadog.PtrString("Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"),
HostFilters: []string{},
},
Type: datadogV2.GCPSERVICEACCOUNTTYPE_GCP_SERVICE_ACCOUNT.Ptr(),
},
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewGCPIntegrationApi(apiClient)
resp, r, err := api.CreateGCPSTSAccount(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.CreateGCPSTSAccount`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.CreateGCPSTSAccount`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Create a new entry for your service account returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.GcpIntegrationApi;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountAttributes;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountCreateRequest;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountData;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountResponse;
import com.datadog.api.client.v2.model.GCPServiceAccountType;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPSTSServiceAccountCreateRequest body =
new GCPSTSServiceAccountCreateRequest()
.data(
new GCPSTSServiceAccountData()
.attributes(
new GCPSTSServiceAccountAttributes()
.clientEmail(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"))
.type(GCPServiceAccountType.GCP_SERVICE_ACCOUNT));
try {
GCPSTSServiceAccountResponse result = apiInstance.createGCPSTSAccount(body);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#createGCPSTSAccount");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
// Create a new entry for your service account with account_tags returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.GcpIntegrationApi;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountAttributes;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountCreateRequest;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountData;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountResponse;
import com.datadog.api.client.v2.model.GCPServiceAccountType;
import java.util.Arrays;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPSTSServiceAccountCreateRequest body =
new GCPSTSServiceAccountCreateRequest()
.data(
new GCPSTSServiceAccountData()
.attributes(
new GCPSTSServiceAccountAttributes()
.accountTags(Arrays.asList("lorem", "ipsum"))
.clientEmail(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"))
.type(GCPServiceAccountType.GCP_SERVICE_ACCOUNT));
try {
GCPSTSServiceAccountResponse result = apiInstance.createGCPSTSAccount(body);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#createGCPSTSAccount");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
// Create a new entry for your service account with cloud run revision filters enabled returns "OK"
// response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.GcpIntegrationApi;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountAttributes;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountCreateRequest;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountData;
import com.datadog.api.client.v2.model.GCPSTSServiceAccountResponse;
import com.datadog.api.client.v2.model.GCPServiceAccountType;
import java.util.Collections;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPSTSServiceAccountCreateRequest body =
new GCPSTSServiceAccountCreateRequest()
.data(
new GCPSTSServiceAccountData()
.attributes(
new GCPSTSServiceAccountAttributes()
.cloudRunRevisionFilters(Collections.singletonList("meh:bleh"))
.clientEmail(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com"))
.type(GCPServiceAccountType.GCP_SERVICE_ACCOUNT));
try {
GCPSTSServiceAccountResponse result = apiInstance.createGCPSTSAccount(body);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#createGCPSTSAccount");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
"""
Create a new entry for your service account returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v2.model.gcp_service_account_type import GCPServiceAccountType
from datadog_api_client.v2.model.gcpsts_service_account_attributes import GCPSTSServiceAccountAttributes
from datadog_api_client.v2.model.gcpsts_service_account_create_request import GCPSTSServiceAccountCreateRequest
from datadog_api_client.v2.model.gcpsts_service_account_data import GCPSTSServiceAccountData
body = GCPSTSServiceAccountCreateRequest(
data=GCPSTSServiceAccountData(
attributes=GCPSTSServiceAccountAttributes(
client_email="Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters=[],
),
type=GCPServiceAccountType.GCP_SERVICE_ACCOUNT,
),
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.create_gcpsts_account(body=body)
print(response)
"""
Create a new entry for your service account with account_tags returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v2.model.gcp_service_account_type import GCPServiceAccountType
from datadog_api_client.v2.model.gcpsts_service_account_attributes import GCPSTSServiceAccountAttributes
from datadog_api_client.v2.model.gcpsts_service_account_create_request import GCPSTSServiceAccountCreateRequest
from datadog_api_client.v2.model.gcpsts_service_account_data import GCPSTSServiceAccountData
body = GCPSTSServiceAccountCreateRequest(
data=GCPSTSServiceAccountData(
attributes=GCPSTSServiceAccountAttributes(
account_tags=[
"lorem",
"ipsum",
],
client_email="Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters=[],
),
type=GCPServiceAccountType.GCP_SERVICE_ACCOUNT,
),
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.create_gcpsts_account(body=body)
print(response)
"""
Create a new entry for your service account with cloud run revision filters enabled returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v2.model.gcp_service_account_type import GCPServiceAccountType
from datadog_api_client.v2.model.gcpsts_service_account_attributes import GCPSTSServiceAccountAttributes
from datadog_api_client.v2.model.gcpsts_service_account_create_request import GCPSTSServiceAccountCreateRequest
from datadog_api_client.v2.model.gcpsts_service_account_data import GCPSTSServiceAccountData
body = GCPSTSServiceAccountCreateRequest(
data=GCPSTSServiceAccountData(
attributes=GCPSTSServiceAccountAttributes(
cloud_run_revision_filters=[
"meh:bleh",
],
client_email="Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters=[],
),
type=GCPServiceAccountType.GCP_SERVICE_ACCOUNT,
),
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.create_gcpsts_account(body=body)
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# Create a new entry for your service account returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V2::GCPIntegrationAPI.new
body = DatadogAPIClient::V2::GCPSTSServiceAccountCreateRequest.new({
data: DatadogAPIClient::V2::GCPSTSServiceAccountData.new({
attributes: DatadogAPIClient::V2::GCPSTSServiceAccountAttributes.new({
client_email: "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters: [],
}),
type: DatadogAPIClient::V2::GCPServiceAccountType::GCP_SERVICE_ACCOUNT,
}),
})
p api_instance.create_gcpsts_account(body)
# Create a new entry for your service account with account_tags returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V2::GCPIntegrationAPI.new
body = DatadogAPIClient::V2::GCPSTSServiceAccountCreateRequest.new({
data: DatadogAPIClient::V2::GCPSTSServiceAccountData.new({
attributes: DatadogAPIClient::V2::GCPSTSServiceAccountAttributes.new({
account_tags: [
"lorem",
"ipsum",
],
client_email: "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters: [],
}),
type: DatadogAPIClient::V2::GCPServiceAccountType::GCP_SERVICE_ACCOUNT,
}),
})
p api_instance.create_gcpsts_account(body)
# Create a new entry for your service account with cloud run revision filters enabled returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V2::GCPIntegrationAPI.new
body = DatadogAPIClient::V2::GCPSTSServiceAccountCreateRequest.new({
data: DatadogAPIClient::V2::GCPSTSServiceAccountData.new({
attributes: DatadogAPIClient::V2::GCPSTSServiceAccountAttributes.new({
cloud_run_revision_filters: [
"meh:bleh",
],
client_email: "Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
host_filters: [],
}),
type: DatadogAPIClient::V2::GCPServiceAccountType::GCP_SERVICE_ACCOUNT,
}),
})
p api_instance.create_gcpsts_account(body)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Create a new entry for your service account returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountAttributes;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountCreateRequest;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountData;
use datadog_api_client::datadogV2::model::GCPServiceAccountType;
#[tokio::main]
async fn main() {
let body = GCPSTSServiceAccountCreateRequest::new().data(
GCPSTSServiceAccountData::new()
.attributes(
GCPSTSServiceAccountAttributes::new()
.client_email(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com".to_string(),
)
.host_filters(vec![]),
)
.type_(GCPServiceAccountType::GCP_SERVICE_ACCOUNT),
);
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.create_gcpsts_account(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
// Create a new entry for your service account with account_tags returns "OK"
// response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountAttributes;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountCreateRequest;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountData;
use datadog_api_client::datadogV2::model::GCPServiceAccountType;
#[tokio::main]
async fn main() {
let body = GCPSTSServiceAccountCreateRequest::new().data(
GCPSTSServiceAccountData::new()
.attributes(
GCPSTSServiceAccountAttributes::new()
.account_tags(vec!["lorem".to_string(), "ipsum".to_string()])
.client_email(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com".to_string(),
)
.host_filters(vec![]),
)
.type_(GCPServiceAccountType::GCP_SERVICE_ACCOUNT),
);
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.create_gcpsts_account(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
// Create a new entry for your service account with cloud run revision filters
// enabled returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountAttributes;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountCreateRequest;
use datadog_api_client::datadogV2::model::GCPSTSServiceAccountData;
use datadog_api_client::datadogV2::model::GCPServiceAccountType;
#[tokio::main]
async fn main() {
let body = GCPSTSServiceAccountCreateRequest::new().data(
GCPSTSServiceAccountData::new()
.attributes(
GCPSTSServiceAccountAttributes::new()
.client_email(
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com".to_string(),
)
.cloud_run_revision_filters(vec!["meh:bleh".to_string()])
.host_filters(vec![]),
)
.type_(GCPServiceAccountType::GCP_SERVICE_ACCOUNT),
);
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.create_gcpsts_account(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* Create a new entry for your service account returns "OK" response
*/
import { client, v2 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v2.GCPIntegrationApi(configuration);
const params: v2.GCPIntegrationApiCreateGCPSTSAccountRequest = {
body: {
data: {
attributes: {
clientEmail:
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
hostFilters: [],
},
type: "gcp_service_account",
},
},
};
apiInstance
.createGCPSTSAccount(params)
.then((data: v2.GCPSTSServiceAccountResponse) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
/**
* Create a new entry for your service account with account_tags returns "OK" response
*/
import { client, v2 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v2.GCPIntegrationApi(configuration);
const params: v2.GCPIntegrationApiCreateGCPSTSAccountRequest = {
body: {
data: {
attributes: {
accountTags: ["lorem", "ipsum"],
clientEmail:
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
hostFilters: [],
},
type: "gcp_service_account",
},
},
};
apiInstance
.createGCPSTSAccount(params)
.then((data: v2.GCPSTSServiceAccountResponse) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
/**
* Create a new entry for your service account with cloud run revision filters enabled returns "OK" response
*/
import { client, v2 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v2.GCPIntegrationApi(configuration);
const params: v2.GCPIntegrationApiCreateGCPSTSAccountRequest = {
body: {
data: {
attributes: {
cloudRunRevisionFilters: ["meh:bleh"],
clientEmail:
"Test-252bf553ef04b351@test-project.iam.gserviceaccount.com",
hostFilters: [],
},
type: "gcp_service_account",
},
},
};
apiInstance
.createGCPSTSAccount(params)
.then((data: v2.GCPSTSServiceAccountResponse) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
DELETE https://api.ap1.datadoghq.com/api/v1/integration/gcphttps://api.datadoghq.eu/api/v1/integration/gcphttps://api.ddog-gov.com/api/v1/integration/gcphttps://api.datadoghq.com/api/v1/integration/gcphttps://api.us3.datadoghq.com/api/v1/integration/gcphttps://api.us5.datadoghq.com/api/v1/integration/gcp
This endpoint is deprecated – use the V2 endpoints instead. Delete a given Datadog-GCP integration.
This endpoint requires the gcp_configurations_manage
permission.
Delete a given Datadog-GCP integration.
{
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"project_id": "datadog-apitest"
}
OK
{}
Bad Request
Error response object.
{
"errors": [
"Bad Request"
]
}
Authentication error
Error response object.
{
"errors": [
"Bad Request"
]
}
Too many requests
Error response object.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X DELETE "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v1/integration/gcp" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"project_id": "datadog-apitest"
}
EOF
// Delete a GCP integration returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)
func main() {
body := datadogV1.GCPAccount{
ClientEmail: datadog.PtrString("252bf553ef04b351@example.com"),
ClientId: datadog.PtrString("163662907116366290710"),
ProjectId: datadog.PtrString("datadog-apitest"),
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV1.NewGCPIntegrationApi(apiClient)
resp, r, err := api.DeleteGCPIntegration(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.DeleteGCPIntegration`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.DeleteGCPIntegration`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Delete a GCP integration returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v1.api.GcpIntegrationApi;
import com.datadog.api.client.v1.model.GCPAccount;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPAccount body =
new GCPAccount()
.clientEmail("252bf553ef04b351@example.com")
.clientId("163662907116366290710")
.projectId("datadog-apitest");
try {
apiInstance.deleteGCPIntegration(body);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#deleteGCPIntegration");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
from datadog import initialize, api
options = {
'api_key': '<DATADOG_API_KEY>',
'app_key': '<DATADOG_APPLICATION_KEY>'
}
initialize(**options)
api.GcpIntegration.delete(
project_id="<GCP_PROJECT_ID>",
client_email="<GCP_CLIENT_EMAIL>"
)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python "example.py"
"""
Delete a GCP integration returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v1.model.gcp_account import GCPAccount
body = GCPAccount(
client_email="252bf553ef04b351@example.com",
client_id="163662907116366290710",
project_id="datadog-apitest",
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.delete_gcp_integration(body=body)
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
require 'rubygems'
require 'dogapi'
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
config = {
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<GCP_CLIENT_EMAIL>"
}
dog.gcp_integration_delete(config)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
# Delete a GCP integration returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V1::GCPIntegrationAPI.new
body = DatadogAPIClient::V1::GCPAccount.new({
client_email: "252bf553ef04b351@example.com",
client_id: "163662907116366290710",
project_id: "datadog-apitest",
})
p api_instance.delete_gcp_integration(body)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Delete a GCP integration returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV1::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV1::model::GCPAccount;
#[tokio::main]
async fn main() {
let body = GCPAccount::new()
.client_email("252bf553ef04b351@example.com".to_string())
.client_id("163662907116366290710".to_string())
.project_id("datadog-apitest".to_string());
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.delete_gcp_integration(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* Delete a GCP integration returns "OK" response
*/
import { client, v1 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v1.GCPIntegrationApi(configuration);
const params: v1.GCPIntegrationApiDeleteGCPIntegrationRequest = {
body: {
clientEmail: "252bf553ef04b351@example.com",
clientId: "163662907116366290710",
projectId: "datadog-apitest",
},
};
apiInstance
.deleteGCPIntegration(params)
.then((data: any) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
DELETE https://api.ap1.datadoghq.com/api/v2/integration/gcp/accounts/{account_id}https://api.datadoghq.eu/api/v2/integration/gcp/accounts/{account_id}https://api.ddog-gov.com/api/v2/integration/gcp/accounts/{account_id}https://api.datadoghq.com/api/v2/integration/gcp/accounts/{account_id}https://api.us3.datadoghq.com/api/v2/integration/gcp/accounts/{account_id}https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts/{account_id}
Delete an STS enabled GCP account from within Datadog.
This endpoint requires the gcp_configurations_manage
permission.
이름
유형
설명
account_id [required]
string
Your GCP STS enabled service account’s unique ID.
No Content
Bad Request
API error response.
{
"errors": [
"Bad Request"
]
}
Not Authorized
API error response.
{
"errors": [
"Bad Request"
]
}
Too many requests
API error response.
{
"errors": [
"Bad Request"
]
}
# Path parameters
export account_id="CHANGE_ME"
# Curl command
curl -X DELETE "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/integration/gcp/accounts/${account_id}" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}"
"""
Delete an STS enabled GCP Account returns "No Content" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.gcp_integration_api import GCPIntegrationApi
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
api_instance.delete_gcpsts_account(
account_id="account_id",
)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# Delete an STS enabled GCP Account returns "No Content" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V2::GCPIntegrationAPI.new
api_instance.delete_gcpsts_account("account_id")
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Delete an STS enabled GCP Account returns "No Content" response
package main
import (
"context"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)
func main() {
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV2.NewGCPIntegrationApi(apiClient)
r, err := api.DeleteGCPSTSAccount(ctx, "account_id")
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.DeleteGCPSTSAccount`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Delete an STS enabled GCP Account returns "No Content" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.GcpIntegrationApi;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
try {
apiInstance.deleteGCPSTSAccount("account_id");
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#deleteGCPSTSAccount");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
// Delete an STS enabled GCP Account returns "No Content" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_gcp_integration::GCPIntegrationAPI;
#[tokio::main]
async fn main() {
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.delete_gcpsts_account("account_id".to_string()).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* Delete an STS enabled GCP Account returns "No Content" response
*/
import { client, v2 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v2.GCPIntegrationApi(configuration);
const params: v2.GCPIntegrationApiDeleteGCPSTSAccountRequest = {
accountId: "account_id",
};
apiInstance
.deleteGCPSTSAccount(params)
.then((data: any) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
First install the library and its dependencies and then save the example to example.ts
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" tsc "example.ts"
PUT https://api.ap1.datadoghq.com/api/v1/integration/gcphttps://api.datadoghq.eu/api/v1/integration/gcphttps://api.ddog-gov.com/api/v1/integration/gcphttps://api.datadoghq.com/api/v1/integration/gcphttps://api.us3.datadoghq.com/api/v1/integration/gcphttps://api.us5.datadoghq.com/api/v1/integration/gcp
This endpoint is deprecated – use the V2 endpoints instead. Update a Datadog-GCP integrations host_filters and/or auto-mute.
Requires a project_id
and client_email
, however these fields cannot be updated.
If you need to update these fields, delete and use the create (POST
) endpoint.
The unspecified fields will keep their original values.
This endpoint requires the gcp_configuration_edit
permission.
Update a Datadog-GCP integration.
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"cloud_run_revision_filters": [
"merp:derp"
],
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
OK
{}
Bad Request
Error response object.
{
"errors": [
"Bad Request"
]
}
Authentication error
Error response object.
{
"errors": [
"Bad Request"
]
}
Too many requests
Error response object.
{
"errors": [
"Bad Request"
]
}
# Curl command
curl -X PUT "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v1/integration/gcp" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"cloud_run_revision_filters": [
"merp:derp"
],
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
EOF
# Curl command
curl -X PUT "https://api.ap1.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v1/integration/gcp" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "DD-API-KEY: ${DD_API_KEY}" \
-H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
-d @- << EOF
{
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"client_email": "252bf553ef04b351@example.com",
"client_id": "163662907116366290710",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
"host_filters": "key:value,filter:example",
"is_cspm_enabled": true,
"is_security_command_center_enabled": true,
"is_resource_change_collection_enabled": true,
"private_key": "private_key",
"private_key_id": "123456789abcdefghi123456789abcdefghijklm",
"project_id": "datadog-apitest",
"resource_collection_enabled": true,
"token_uri": "https://accounts.google.com/o/oauth2/token",
"type": "service_account"
}
EOF
// Update a GCP integration cloud run revision filters returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)
func main() {
body := datadogV1.GCPAccount{
AuthProviderX509CertUrl: datadog.PtrString("https://www.googleapis.com/oauth2/v1/certs"),
AuthUri: datadog.PtrString("https://accounts.google.com/o/oauth2/auth"),
ClientEmail: datadog.PtrString("252bf553ef04b351@example.com"),
ClientId: datadog.PtrString("163662907116366290710"),
ClientX509CertUrl: datadog.PtrString("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL"),
HostFilters: datadog.PtrString("key:value,filter:example"),
CloudRunRevisionFilters: []string{
"merp:derp",
},
IsCspmEnabled: datadog.PtrBool(true),
IsSecurityCommandCenterEnabled: datadog.PtrBool(true),
PrivateKey: datadog.PtrString("private_key"),
PrivateKeyId: datadog.PtrString("123456789abcdefghi123456789abcdefghijklm"),
ProjectId: datadog.PtrString("datadog-apitest"),
ResourceCollectionEnabled: datadog.PtrBool(true),
TokenUri: datadog.PtrString("https://accounts.google.com/o/oauth2/token"),
Type: datadog.PtrString("service_account"),
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV1.NewGCPIntegrationApi(apiClient)
resp, r, err := api.UpdateGCPIntegration(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.UpdateGCPIntegration`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.UpdateGCPIntegration`:\n%s\n", responseContent)
}
// Update a GCP integration returns "OK" response
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
"github.com/DataDog/datadog-api-client-go/v2/api/datadogV1"
)
func main() {
body := datadogV1.GCPAccount{
AuthProviderX509CertUrl: datadog.PtrString("https://www.googleapis.com/oauth2/v1/certs"),
AuthUri: datadog.PtrString("https://accounts.google.com/o/oauth2/auth"),
ClientEmail: datadog.PtrString("252bf553ef04b351@example.com"),
ClientId: datadog.PtrString("163662907116366290710"),
ClientX509CertUrl: datadog.PtrString("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL"),
HostFilters: datadog.PtrString("key:value,filter:example"),
IsCspmEnabled: datadog.PtrBool(true),
IsSecurityCommandCenterEnabled: datadog.PtrBool(true),
PrivateKey: datadog.PtrString("private_key"),
PrivateKeyId: datadog.PtrString("123456789abcdefghi123456789abcdefghijklm"),
ProjectId: datadog.PtrString("datadog-apitest"),
ResourceCollectionEnabled: datadog.PtrBool(true),
TokenUri: datadog.PtrString("https://accounts.google.com/o/oauth2/token"),
Type: datadog.PtrString("service_account"),
}
ctx := datadog.NewDefaultContext(context.Background())
configuration := datadog.NewConfiguration()
apiClient := datadog.NewAPIClient(configuration)
api := datadogV1.NewGCPIntegrationApi(apiClient)
resp, r, err := api.UpdateGCPIntegration(ctx, body)
if err != nil {
fmt.Fprintf(os.Stderr, "Error when calling `GCPIntegrationApi.UpdateGCPIntegration`: %v\n", err)
fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
}
responseContent, _ := json.MarshalIndent(resp, "", " ")
fmt.Fprintf(os.Stdout, "Response from `GCPIntegrationApi.UpdateGCPIntegration`:\n%s\n", responseContent)
}
First install the library and its dependencies and then save the example to main.go
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" go run "main.go"
// Update a GCP integration cloud run revision filters returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v1.api.GcpIntegrationApi;
import com.datadog.api.client.v1.model.GCPAccount;
import java.util.Collections;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPAccount body =
new GCPAccount()
.authProviderX509CertUrl("https://www.googleapis.com/oauth2/v1/certs")
.authUri("https://accounts.google.com/o/oauth2/auth")
.clientEmail("252bf553ef04b351@example.com")
.clientId("163662907116366290710")
.clientX509CertUrl("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL")
.hostFilters("key:value,filter:example")
.cloudRunRevisionFilters(Collections.singletonList("merp:derp"))
.isCspmEnabled(true)
.isSecurityCommandCenterEnabled(true)
.privateKey("private_key")
.privateKeyId("123456789abcdefghi123456789abcdefghijklm")
.projectId("datadog-apitest")
.resourceCollectionEnabled(true)
.tokenUri("https://accounts.google.com/o/oauth2/token")
.type("service_account");
try {
apiInstance.updateGCPIntegration(body);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#updateGCPIntegration");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
// Update a GCP integration returns "OK" response
import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v1.api.GcpIntegrationApi;
import com.datadog.api.client.v1.model.GCPAccount;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = ApiClient.getDefaultApiClient();
GcpIntegrationApi apiInstance = new GcpIntegrationApi(defaultClient);
GCPAccount body =
new GCPAccount()
.authProviderX509CertUrl("https://www.googleapis.com/oauth2/v1/certs")
.authUri("https://accounts.google.com/o/oauth2/auth")
.clientEmail("252bf553ef04b351@example.com")
.clientId("163662907116366290710")
.clientX509CertUrl("https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL")
.hostFilters("key:value,filter:example")
.isCspmEnabled(true)
.isSecurityCommandCenterEnabled(true)
.privateKey("private_key")
.privateKeyId("123456789abcdefghi123456789abcdefghijklm")
.projectId("datadog-apitest")
.resourceCollectionEnabled(true)
.tokenUri("https://accounts.google.com/o/oauth2/token")
.type("service_account");
try {
apiInstance.updateGCPIntegration(body);
} catch (ApiException e) {
System.err.println("Exception when calling GcpIntegrationApi#updateGCPIntegration");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
First install the library and its dependencies and then save the example to Example.java
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" java "Example.java"
"""
Update a GCP integration cloud run revision filters returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v1.model.gcp_account import GCPAccount
body = GCPAccount(
auth_provider_x509_cert_url="https://www.googleapis.com/oauth2/v1/certs",
auth_uri="https://accounts.google.com/o/oauth2/auth",
client_email="252bf553ef04b351@example.com",
client_id="163662907116366290710",
client_x509_cert_url="https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters="key:value,filter:example",
cloud_run_revision_filters=[
"merp:derp",
],
is_cspm_enabled=True,
is_security_command_center_enabled=True,
private_key="private_key",
private_key_id="123456789abcdefghi123456789abcdefghijklm",
project_id="datadog-apitest",
resource_collection_enabled=True,
token_uri="https://accounts.google.com/o/oauth2/token",
type="service_account",
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.update_gcp_integration(body=body)
print(response)
"""
Update a GCP integration returns "OK" response
"""
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v1.api.gcp_integration_api import GCPIntegrationApi
from datadog_api_client.v1.model.gcp_account import GCPAccount
body = GCPAccount(
auth_provider_x509_cert_url="https://www.googleapis.com/oauth2/v1/certs",
auth_uri="https://accounts.google.com/o/oauth2/auth",
client_email="252bf553ef04b351@example.com",
client_id="163662907116366290710",
client_x509_cert_url="https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters="key:value,filter:example",
is_cspm_enabled=True,
is_security_command_center_enabled=True,
private_key="private_key",
private_key_id="123456789abcdefghi123456789abcdefghijklm",
project_id="datadog-apitest",
resource_collection_enabled=True,
token_uri="https://accounts.google.com/o/oauth2/token",
type="service_account",
)
configuration = Configuration()
with ApiClient(configuration) as api_client:
api_instance = GCPIntegrationApi(api_client)
response = api_instance.update_gcp_integration(body=body)
print(response)
First install the library and its dependencies and then save the example to example.py
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" python3 "example.py"
# Update a GCP integration cloud run revision filters returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V1::GCPIntegrationAPI.new
body = DatadogAPIClient::V1::GCPAccount.new({
auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs",
auth_uri: "https://accounts.google.com/o/oauth2/auth",
client_email: "252bf553ef04b351@example.com",
client_id: "163662907116366290710",
client_x509_cert_url: "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters: "key:value,filter:example",
cloud_run_revision_filters: [
"merp:derp",
],
is_cspm_enabled: true,
is_security_command_center_enabled: true,
private_key: "private_key",
private_key_id: "123456789abcdefghi123456789abcdefghijklm",
project_id: "datadog-apitest",
resource_collection_enabled: true,
token_uri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
})
p api_instance.update_gcp_integration(body)
# Update a GCP integration returns "OK" response
require "datadog_api_client"
api_instance = DatadogAPIClient::V1::GCPIntegrationAPI.new
body = DatadogAPIClient::V1::GCPAccount.new({
auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs",
auth_uri: "https://accounts.google.com/o/oauth2/auth",
client_email: "252bf553ef04b351@example.com",
client_id: "163662907116366290710",
client_x509_cert_url: "https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
host_filters: "key:value,filter:example",
is_cspm_enabled: true,
is_security_command_center_enabled: true,
private_key: "private_key",
private_key_id: "123456789abcdefghi123456789abcdefghijklm",
project_id: "datadog-apitest",
resource_collection_enabled: true,
token_uri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
})
p api_instance.update_gcp_integration(body)
First install the library and its dependencies and then save the example to example.rb
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" rb "example.rb"
// Update a GCP integration cloud run revision filters returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV1::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV1::model::GCPAccount;
#[tokio::main]
async fn main() {
let body = GCPAccount::new()
.auth_provider_x509_cert_url("https://www.googleapis.com/oauth2/v1/certs".to_string())
.auth_uri("https://accounts.google.com/o/oauth2/auth".to_string())
.client_email("252bf553ef04b351@example.com".to_string())
.client_id("163662907116366290710".to_string())
.client_x509_cert_url(
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL".to_string(),
)
.cloud_run_revision_filters(vec!["merp:derp".to_string()])
.host_filters("key:value,filter:example".to_string())
.is_cspm_enabled(true)
.is_security_command_center_enabled(true)
.private_key("private_key".to_string())
.private_key_id("123456789abcdefghi123456789abcdefghijklm".to_string())
.project_id("datadog-apitest".to_string())
.resource_collection_enabled(true)
.token_uri("https://accounts.google.com/o/oauth2/token".to_string())
.type_("service_account".to_string());
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.update_gcp_integration(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
// Update a GCP integration returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV1::api_gcp_integration::GCPIntegrationAPI;
use datadog_api_client::datadogV1::model::GCPAccount;
#[tokio::main]
async fn main() {
let body = GCPAccount::new()
.auth_provider_x509_cert_url("https://www.googleapis.com/oauth2/v1/certs".to_string())
.auth_uri("https://accounts.google.com/o/oauth2/auth".to_string())
.client_email("252bf553ef04b351@example.com".to_string())
.client_id("163662907116366290710".to_string())
.client_x509_cert_url(
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL".to_string(),
)
.host_filters("key:value,filter:example".to_string())
.is_cspm_enabled(true)
.is_security_command_center_enabled(true)
.private_key("private_key".to_string())
.private_key_id("123456789abcdefghi123456789abcdefghijklm".to_string())
.project_id("datadog-apitest".to_string())
.resource_collection_enabled(true)
.token_uri("https://accounts.google.com/o/oauth2/token".to_string())
.type_("service_account".to_string());
let configuration = datadog::Configuration::new();
let api = GCPIntegrationAPI::with_config(configuration);
let resp = api.update_gcp_integration(body).await;
if let Ok(value) = resp {
println!("{:#?}", value);
} else {
println!("{:#?}", resp.unwrap_err());
}
}
First install the library and its dependencies and then save the example to src/main.rs
and run following commands:
DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comddog-gov.com" DD_API_KEY="<API-KEY>" DD_APP_KEY="<APP-KEY>" cargo run
/**
* Update a GCP integration cloud run revision filters returns "OK" response
*/
import { client, v1 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v1.GCPIntegrationApi(configuration);
const params: v1.GCPIntegrationApiUpdateGCPIntegrationRequest = {
body: {
authProviderX509CertUrl: "https://www.googleapis.com/oauth2/v1/certs",
authUri: "https://accounts.google.com/o/oauth2/auth",
clientEmail: "252bf553ef04b351@example.com",
clientId: "163662907116366290710",
clientX509CertUrl:
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
hostFilters: "key:value,filter:example",
cloudRunRevisionFilters: ["merp:derp"],
isCspmEnabled: true,
isSecurityCommandCenterEnabled: true,
privateKey: "private_key",
privateKeyId: "123456789abcdefghi123456789abcdefghijklm",
projectId: "datadog-apitest",
resourceCollectionEnabled: true,
tokenUri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
},
};
apiInstance
.updateGCPIntegration(params)
.then((data: any) => {
console.log(
"API called successfully. Returned data: " + JSON.stringify(data)
);
})
.catch((error: any) => console.error(error));
/**
* Update a GCP integration returns "OK" response
*/
import { client, v1 } from "@datadog/datadog-api-client";
const configuration = client.createConfiguration();
const apiInstance = new v1.GCPIntegrationApi(configuration);
const params: v1.GCPIntegrationApiUpdateGCPIntegrationRequest = {
body: {
authProviderX509CertUrl: "https://www.googleapis.com/oauth2/v1/certs",
authUri: "https://accounts.google.com/o/oauth2/auth",
clientEmail: "252bf553ef04b351@example.com",
clientId: "163662907116366290710",
clientX509CertUrl:
"https://www.googleapis.com/robot/v1/metadata/x509/$CLIENT_EMAIL",
hostFilters: "key:value,filter:example",
isCspmEnabled: true,
isSecurityCommandCenterEnabled: true,
privateKey: "private_key",
privateKeyId: "123456789abcdefghi123456789abcdefghijklm",
projectId: "datadog-apitest",
resourceCollectionEnabled: true,
tokenUri: "https://accounts.google.com/o/oauth2/token",
type: "service_account",
},
};
apiInstance
.updateGCPIntegration(params)
.