Protection

using Pulumi;
using Aws = Pulumi.Aws;

class MyStack : Stack
{
    public MyStack()
    {
        var available = Output.Create(Aws.GetAvailabilityZones.InvokeAsync());
        var currentRegion = Output.Create(Aws.GetRegion.InvokeAsync());
        var currentCallerIdentity = Output.Create(Aws.GetCallerIdentity.InvokeAsync());
        var fooEip = new Aws.Ec2.Eip("fooEip", new Aws.Ec2.EipArgs
        {
            Vpc = true,
        });
        var fooProtection = new Aws.Shield.Protection("fooProtection", new Aws.Shield.ProtectionArgs
        {
            ResourceArn = Output.Tuple(currentRegion, currentCallerIdentity, fooEip.Id).Apply(values =>
            {
                var currentRegion = values.Item1;
                var currentCallerIdentity = values.Item2;
                var id = values.Item3;
                return $"arn:aws:ec2:{currentRegion.Name}:{currentCallerIdentity.AccountId}:eip-allocation/{id}";
            }),
        });
    }

}

package main

import (
    "fmt"

    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws"
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/ec2"
    "github.com/pulumi/pulumi-aws/sdk/v2/go/aws/shield"
    "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        _, err := aws.GetAvailabilityZones(ctx, nil, nil)
        if err != nil {
            return err
        }
        currentRegion, err := aws.GetRegion(ctx, nil, nil)
        if err != nil {
            return err
        }
        currentCallerIdentity, err := aws.GetCallerIdentity(ctx, nil, nil)
        if err != nil {
            return err
        }
        fooEip, err := ec2.NewEip(ctx, "fooEip", &ec2.EipArgs{
            Vpc: pulumi.Bool(true),
        })
        if err != nil {
            return err
        }
        _, err = shield.NewProtection(ctx, "fooProtection", &shield.ProtectionArgs{
            ResourceArn: fooEip.ID().ApplyT(func(id string) (string, error) {
                return fmt.Sprintf("%v%v%v%v%v%v", "arn:aws:ec2:", currentRegion.Name, ":", currentCallerIdentity.AccountId, ":eip-allocation/", id), nil
            }).(pulumi.StringOutput),
        })
        if err != nil {
            return err
        }
        return nil
    })
}

import pulumi
import pulumi_aws as aws

available = aws.get_availability_zones()
current_region = aws.get_region()
current_caller_identity = aws.get_caller_identity()
foo_eip = aws.ec2.Eip("fooEip", vpc=True)
foo_protection = aws.shield.Protection("fooProtection", resource_arn=foo_eip.id.apply(lambda id: f"arn:aws:ec2:{current_region.name}:{current_caller_identity.account_id}:eip-allocation/{id}"))

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

const available = pulumi.output(aws.getAvailabilityZones({ async: true }));
const currentRegion = pulumi.output(aws.getRegion({ async: true }));
const currentCallerIdentity = pulumi.output(aws.getCallerIdentity({ async: true }));
const fooEip = new aws.ec2.Eip("foo", {
    vpc: true,
});
const fooProtection = new aws.shield.Protection("foo", {
    resourceArn: pulumi.interpolate`arn:aws:ec2:${currentRegion.name!}:${currentCallerIdentity.accountId}:eip-allocation/${fooEip.id}`,
});