Enable Storage Management for a bucket

// Enable Storage Management for a bucket 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.UpsertCloudInventorySyncConfigRequest{
		Data: datadogV2.UpsertCloudInventorySyncConfigRequestData{
			Attributes: datadogV2.UpsertCloudInventorySyncConfigRequestAttributes{
				Aws: &datadogV2.CloudInventorySyncConfigAWSRequestAttributes{
					AwsAccountId:            "123456789012",
					DestinationBucketName:   "my-inventory-bucket",
					DestinationBucketRegion: "us-east-1",
					DestinationPrefix:       datadog.PtrString("logs/"),
				},
				Azure: &datadogV2.CloudInventorySyncConfigAzureRequestAttributes{
					ClientId:       "11111111-1111-1111-1111-111111111111",
					Container:      "inventory-container",
					ResourceGroup:  "my-resource-group",
					StorageAccount: "mystorageaccount",
					SubscriptionId: "33333333-3333-3333-3333-333333333333",
					TenantId:       "22222222-2222-2222-2222-222222222222",
				},
				Gcp: &datadogV2.CloudInventorySyncConfigGCPRequestAttributes{
					DestinationBucketName: "my-inventory-reports",
					ProjectId:             "my-gcp-project",
					ServiceAccountEmail:   "reader@my-gcp-project.iam.gserviceaccount.com",
					SourceBucketName:      "my-monitored-bucket",
				},
			},
			Id:   datadogV2.CLOUDINVENTORYCLOUDPROVIDERID_AWS,
			Type: datadogV2.CLOUDINVENTORYCLOUDPROVIDERREQUESTTYPE_CLOUD_PROVIDER,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewStorageManagementApi(apiClient)
	resp, r, err := api.UpsertSyncConfig(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `StorageManagementApi.UpsertSyncConfig`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `StorageManagementApi.UpsertSyncConfig`:\n%s\n", responseContent)
}

// Enable Storage Management for a bucket returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.StorageManagementApi;
import com.datadog.api.client.v2.model.CloudInventoryCloudProviderId;
import com.datadog.api.client.v2.model.CloudInventoryCloudProviderRequestType;
import com.datadog.api.client.v2.model.CloudInventorySyncConfigAWSRequestAttributes;
import com.datadog.api.client.v2.model.CloudInventorySyncConfigAzureRequestAttributes;
import com.datadog.api.client.v2.model.CloudInventorySyncConfigGCPRequestAttributes;
import com.datadog.api.client.v2.model.CloudInventorySyncConfigResponse;
import com.datadog.api.client.v2.model.UpsertCloudInventorySyncConfigRequest;
import com.datadog.api.client.v2.model.UpsertCloudInventorySyncConfigRequestAttributes;
import com.datadog.api.client.v2.model.UpsertCloudInventorySyncConfigRequestData;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    StorageManagementApi apiInstance = new StorageManagementApi(defaultClient);

    UpsertCloudInventorySyncConfigRequest body =
        new UpsertCloudInventorySyncConfigRequest()
            .data(
                new UpsertCloudInventorySyncConfigRequestData()
                    .attributes(
                        new UpsertCloudInventorySyncConfigRequestAttributes()
                            .aws(
                                new CloudInventorySyncConfigAWSRequestAttributes()
                                    .awsAccountId("123456789012")
                                    .destinationBucketName("my-inventory-bucket")
                                    .destinationBucketRegion("us-east-1")
                                    .destinationPrefix("logs/"))
                            .azure(
                                new CloudInventorySyncConfigAzureRequestAttributes()
                                    .clientId("11111111-1111-1111-1111-111111111111")
                                    .container("inventory-container")
                                    .resourceGroup("my-resource-group")
                                    .storageAccount("mystorageaccount")
                                    .subscriptionId("33333333-3333-3333-3333-333333333333")
                                    .tenantId("22222222-2222-2222-2222-222222222222"))
                            .gcp(
                                new CloudInventorySyncConfigGCPRequestAttributes()
                                    .destinationBucketName("my-inventory-reports")
                                    .projectId("my-gcp-project")
                                    .serviceAccountEmail(
                                        "reader@my-gcp-project.iam.gserviceaccount.com")
                                    .sourceBucketName("my-monitored-bucket")))
                    .id(CloudInventoryCloudProviderId.AWS)
                    .type(CloudInventoryCloudProviderRequestType.CLOUD_PROVIDER));

    try {
      CloudInventorySyncConfigResponse result = apiInstance.upsertSyncConfig(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling StorageManagementApi#upsertSyncConfig");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

"""
Enable Storage Management for a bucket returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.storage_management_api import StorageManagementApi
from datadog_api_client.v2.model.cloud_inventory_cloud_provider_id import CloudInventoryCloudProviderId
from datadog_api_client.v2.model.cloud_inventory_cloud_provider_request_type import (
    CloudInventoryCloudProviderRequestType,
)
from datadog_api_client.v2.model.cloud_inventory_sync_config_aws_request_attributes import (
    CloudInventorySyncConfigAWSRequestAttributes,
)
from datadog_api_client.v2.model.cloud_inventory_sync_config_azure_request_attributes import (
    CloudInventorySyncConfigAzureRequestAttributes,
)
from datadog_api_client.v2.model.cloud_inventory_sync_config_gcp_request_attributes import (
    CloudInventorySyncConfigGCPRequestAttributes,
)
from datadog_api_client.v2.model.upsert_cloud_inventory_sync_config_request import UpsertCloudInventorySyncConfigRequest
from datadog_api_client.v2.model.upsert_cloud_inventory_sync_config_request_attributes import (
    UpsertCloudInventorySyncConfigRequestAttributes,
)
from datadog_api_client.v2.model.upsert_cloud_inventory_sync_config_request_data import (
    UpsertCloudInventorySyncConfigRequestData,
)

body = UpsertCloudInventorySyncConfigRequest(
    data=UpsertCloudInventorySyncConfigRequestData(
        attributes=UpsertCloudInventorySyncConfigRequestAttributes(
            aws=CloudInventorySyncConfigAWSRequestAttributes(
                aws_account_id="123456789012",
                destination_bucket_name="my-inventory-bucket",
                destination_bucket_region="us-east-1",
                destination_prefix="logs/",
            ),
            azure=CloudInventorySyncConfigAzureRequestAttributes(
                client_id="11111111-1111-1111-1111-111111111111",
                container="inventory-container",
                resource_group="my-resource-group",
                storage_account="mystorageaccount",
                subscription_id="33333333-3333-3333-3333-333333333333",
                tenant_id="22222222-2222-2222-2222-222222222222",
            ),
            gcp=CloudInventorySyncConfigGCPRequestAttributes(
                destination_bucket_name="my-inventory-reports",
                project_id="my-gcp-project",
                service_account_email="reader@my-gcp-project.iam.gserviceaccount.com",
                source_bucket_name="my-monitored-bucket",
            ),
        ),
        id=CloudInventoryCloudProviderId.AWS,
        type=CloudInventoryCloudProviderRequestType.CLOUD_PROVIDER,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
with ApiClient(configuration) as api_client:
    api_instance = StorageManagementApi(api_client)
    response = api_instance.upsert_sync_config(body=body)

    print(response)

# Enable Storage Management for a bucket returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
end
api_instance = DatadogAPIClient::V2::StorageManagementAPI.new

body = DatadogAPIClient::V2::UpsertCloudInventorySyncConfigRequest.new({
  data: DatadogAPIClient::V2::UpsertCloudInventorySyncConfigRequestData.new({
    attributes: DatadogAPIClient::V2::UpsertCloudInventorySyncConfigRequestAttributes.new({
      aws: DatadogAPIClient::V2::CloudInventorySyncConfigAWSRequestAttributes.new({
        aws_account_id: "123456789012",
        destination_bucket_name: "my-inventory-bucket",
        destination_bucket_region: "us-east-1",
        destination_prefix: "logs/",
      }),
      azure: DatadogAPIClient::V2::CloudInventorySyncConfigAzureRequestAttributes.new({
        client_id: "11111111-1111-1111-1111-111111111111",
        container: "inventory-container",
        resource_group: "my-resource-group",
        storage_account: "mystorageaccount",
        subscription_id: "33333333-3333-3333-3333-333333333333",
        tenant_id: "22222222-2222-2222-2222-222222222222",
      }),
      gcp: DatadogAPIClient::V2::CloudInventorySyncConfigGCPRequestAttributes.new({
        destination_bucket_name: "my-inventory-reports",
        project_id: "my-gcp-project",
        service_account_email: "reader@my-gcp-project.iam.gserviceaccount.com",
        source_bucket_name: "my-monitored-bucket",
      }),
    }),
    id: DatadogAPIClient::V2::CloudInventoryCloudProviderId::AWS,
    type: DatadogAPIClient::V2::CloudInventoryCloudProviderRequestType::CLOUD_PROVIDER,
  }),
})
p api_instance.upsert_sync_config(body)

// Enable Storage Management for a bucket returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_storage_management::StorageManagementAPI;
use datadog_api_client::datadogV2::model::CloudInventoryCloudProviderId;
use datadog_api_client::datadogV2::model::CloudInventoryCloudProviderRequestType;
use datadog_api_client::datadogV2::model::CloudInventorySyncConfigAWSRequestAttributes;
use datadog_api_client::datadogV2::model::CloudInventorySyncConfigAzureRequestAttributes;
use datadog_api_client::datadogV2::model::CloudInventorySyncConfigGCPRequestAttributes;
use datadog_api_client::datadogV2::model::UpsertCloudInventorySyncConfigRequest;
use datadog_api_client::datadogV2::model::UpsertCloudInventorySyncConfigRequestAttributes;
use datadog_api_client::datadogV2::model::UpsertCloudInventorySyncConfigRequestData;

#[tokio::main]
async fn main() {
    let body =
        UpsertCloudInventorySyncConfigRequest::new(UpsertCloudInventorySyncConfigRequestData::new(
            UpsertCloudInventorySyncConfigRequestAttributes::new()
                .aws(
                    CloudInventorySyncConfigAWSRequestAttributes::new(
                        "123456789012".to_string(),
                        "my-inventory-bucket".to_string(),
                        "us-east-1".to_string(),
                    )
                    .destination_prefix("logs/".to_string()),
                )
                .azure(CloudInventorySyncConfigAzureRequestAttributes::new(
                    "11111111-1111-1111-1111-111111111111".to_string(),
                    "inventory-container".to_string(),
                    "my-resource-group".to_string(),
                    "mystorageaccount".to_string(),
                    "33333333-3333-3333-3333-333333333333".to_string(),
                    "22222222-2222-2222-2222-222222222222".to_string(),
                ))
                .gcp(CloudInventorySyncConfigGCPRequestAttributes::new(
                    "my-inventory-reports".to_string(),
                    "my-gcp-project".to_string(),
                    "reader@my-gcp-project.iam.gserviceaccount.com".to_string(),
                    "my-monitored-bucket".to_string(),
                )),
            CloudInventoryCloudProviderId::AWS,
            CloudInventoryCloudProviderRequestType::CLOUD_PROVIDER,
        ));
    let configuration = datadog::Configuration::new();
    let api = StorageManagementAPI::with_config(configuration);
    let resp = api.upsert_sync_config(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

/**
 * Enable Storage Management for a bucket returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
const apiInstance = new v2.StorageManagementApi(configuration);

const params: v2.StorageManagementApiUpsertSyncConfigRequest = {
  body: {
    data: {
      attributes: {
        aws: {
          awsAccountId: "123456789012",
          destinationBucketName: "my-inventory-bucket",
          destinationBucketRegion: "us-east-1",
          destinationPrefix: "logs/",
        },
        azure: {
          clientId: "11111111-1111-1111-1111-111111111111",
          container: "inventory-container",
          resourceGroup: "my-resource-group",
          storageAccount: "mystorageaccount",
          subscriptionId: "33333333-3333-3333-3333-333333333333",
          tenantId: "22222222-2222-2222-2222-222222222222",
        },
        gcp: {
          destinationBucketName: "my-inventory-reports",
          projectId: "my-gcp-project",
          serviceAccountEmail: "reader@my-gcp-project.iam.gserviceaccount.com",
          sourceBucketName: "my-monitored-bucket",
        },
      },
      id: "aws",
      type: "cloud_provider",
    },
  },
};

apiInstance
  .upsertSyncConfig(params)
  .then((data: v2.CloudInventorySyncConfigResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));