datadog.AwsWifIdentityMapping

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as datadog from "@pulumi/datadog";

const current = aws.callerIdentity({});
const readOnly = datadog.getRole({
    filter: "Datadog Read Only Role",
});
const terraform = new datadog.ServiceAccount("terraform", {
    email: "terraform-service-account@example.com",
    name: "Terraform service account",
    roles: [readOnly.then(readOnly => readOnly.id)],
});
const terraformAwsWifIdentityMapping = new datadog.AwsWifIdentityMapping("terraform", {
    accountIdentifier: terraform.id,
    arnPattern: `arn:aws:sts::${current.accountId}:assumed-role/terraform-runner/*`,
});

import pulumi
import pulumi_aws as aws
import pulumi_datadog as datadog

current = aws.caller_identity()
read_only = datadog.get_role(filter="Datadog Read Only Role")
terraform = datadog.ServiceAccount("terraform",
    email="terraform-service-account@example.com",
    name="Terraform service account",
    roles=[read_only.id])
terraform_aws_wif_identity_mapping = datadog.AwsWifIdentityMapping("terraform",
    account_identifier=terraform.id,
    arn_pattern=f"arn:aws:sts::{current['accountId']}:assumed-role/terraform-runner/*")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/go/aws"
	"github.com/pulumi/pulumi-datadog/sdk/v5/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := aws.CallerIdentity(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		readOnly, err := datadog.GetRole(ctx, &datadog.LookupRoleArgs{
			Filter: "Datadog Read Only Role",
		}, nil)
		if err != nil {
			return err
		}
		terraform, err := datadog.NewServiceAccount(ctx, "terraform", &datadog.ServiceAccountArgs{
			Email: pulumi.String("terraform-service-account@example.com"),
			Name:  pulumi.String("Terraform service account"),
			Roles: pulumi.StringArray{
				pulumi.String(readOnly.Id),
			},
		})
		if err != nil {
			return err
		}
		_, err = datadog.NewAwsWifIdentityMapping(ctx, "terraform", &datadog.AwsWifIdentityMappingArgs{
			AccountIdentifier: terraform.ID(),
			ArnPattern:        pulumi.Sprintf("arn:aws:sts::%v:assumed-role/terraform-runner/*", current.AccountId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Datadog = Pulumi.Datadog;

return await Deployment.RunAsync(() => 
{
    var current = Aws.CallerIdentity.Invoke();

    var readOnly = Datadog.GetRole.Invoke(new()
    {
        Filter = "Datadog Read Only Role",
    });

    var terraform = new Datadog.ServiceAccount("terraform", new()
    {
        Email = "terraform-service-account@example.com",
        Name = "Terraform service account",
        Roles = new[]
        {
            readOnly.Apply(getRoleResult => getRoleResult.Id),
        },
    });

    var terraformAwsWifIdentityMapping = new Datadog.AwsWifIdentityMapping("terraform", new()
    {
        AccountIdentifier = terraform.Id,
        ArnPattern = $"arn:aws:sts::{current.AccountId}:assumed-role/terraform-runner/*",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.datadog.DatadogFunctions;
import com.pulumi.datadog.inputs.GetRoleArgs;
import com.pulumi.datadog.ServiceAccount;
import com.pulumi.datadog.ServiceAccountArgs;
import com.pulumi.datadog.AwsWifIdentityMapping;
import com.pulumi.datadog.AwsWifIdentityMappingArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var current = AwsFunctions.callerIdentity(Map.ofEntries(
        ));

        final var readOnly = DatadogFunctions.getRole(GetRoleArgs.builder()
            .filter("Datadog Read Only Role")
            .build());

        var terraform = new ServiceAccount("terraform", ServiceAccountArgs.builder()
            .email("terraform-service-account@example.com")
            .name("Terraform service account")
            .roles(readOnly.id())
            .build());

        var terraformAwsWifIdentityMapping = new AwsWifIdentityMapping("terraformAwsWifIdentityMapping", AwsWifIdentityMappingArgs.builder()
            .accountIdentifier(terraform.id())
            .arnPattern(String.format("arn:aws:sts::%s:assumed-role/terraform-runner/*", current.get("accountId")))
            .build());

    }
}

resources:
  terraform:
    type: datadog:ServiceAccount
    properties:
      email: terraform-service-account@example.com
      name: Terraform service account
      roles:
        - ${readOnly.id}
  terraformAwsWifIdentityMapping:
    type: datadog:AwsWifIdentityMapping
    name: terraform
    properties:
      accountIdentifier: ${terraform.id}
      arnPattern: arn:aws:sts::${current.accountId}:assumed-role/terraform-runner/*
variables:
  current:
    fn::invoke:
      function: aws:callerIdentity
      arguments: {}
  readOnly:
    fn::invoke:
      function: datadog:getRole
      arguments:
        filter: Datadog Read Only Role

terraform {
  required_providers {
    datadog = {
      source = "pulumi/datadog"
    }
  }
}

data "aws_caller_identity" "current" {
}
data "datadog_role" "readOnly" {
  filter = "Datadog Read Only Role"
}

resource "datadog_service_account" "terraform" {
  lifecycle {
    create_before_destroy = true
  }
  email = "terraform-service-account@example.com"
  name  = "Terraform service account"
  roles = [data.datadog_role.readOnly.id]
}
resource "datadog_aws_wif_identity_mapping" "terraform" {
  lifecycle {
    create_before_destroy = true
  }
  account_identifier = datadog_service_account.terraform.id
  arn_pattern        ="arn:aws:sts::${data.aws_caller_identity.current.account_id}:assumed-role/terraform-runner/*"
}

var awsWifIdentityMappingResource = new Datadog.AwsWifIdentityMapping("awsWifIdentityMappingResource", new()
{
    AccountIdentifier = "string",
    ArnPattern = "string",
});

example, err := datadog.NewAwsWifIdentityMapping(ctx, "awsWifIdentityMappingResource", &datadog.AwsWifIdentityMappingArgs{
	AccountIdentifier: pulumi.String("string"),
	ArnPattern:        pulumi.String("string"),
})

resource "datadog_aws_wif_identity_mapping" "awsWifIdentityMappingResource" {
  lifecycle {
    create_before_destroy = true
  }
  account_identifier = "string"
  arn_pattern        = "string"
}

var awsWifIdentityMappingResource = new AwsWifIdentityMapping("awsWifIdentityMappingResource", AwsWifIdentityMappingArgs.builder()
    .accountIdentifier("string")
    .arnPattern("string")
    .build());

aws_wif_identity_mapping_resource = datadog.AwsWifIdentityMapping("awsWifIdentityMappingResource",
    account_identifier="string",
    arn_pattern="string")

const awsWifIdentityMappingResource = new datadog.AwsWifIdentityMapping("awsWifIdentityMappingResource", {
    accountIdentifier: "string",
    arnPattern: "string",
});

type: datadog:AwsWifIdentityMapping
properties:
    accountIdentifier: string
    arnPattern: string