aws.sqs.RedriveAllowPolicy

import pulumi
import json
import pulumi_aws as aws

example = aws.sqs.Queue("example", name="examplequeue")
src = aws.sqs.Queue("src",
    name="srcqueue",
    redrive_policy=pulumi.Output.json_dumps({
        "deadLetterTargetArn": example.arn,
        "maxReceiveCount": 4,
    }))
example_redrive_allow_policy = aws.sqs.RedriveAllowPolicy("example",
    queue_url=example.id,
    redrive_allow_policy=pulumi.Output.json_dumps({
        "redrivePermission": "byQueue",
        "sourceQueueArns": [src.arn],
    }))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sqs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sqs.NewQueue(ctx, "example", &sqs.QueueArgs{
			Name: pulumi.String("examplequeue"),
		})
		if err != nil {
			return err
		}
		src, err := sqs.NewQueue(ctx, "src", &sqs.QueueArgs{
			Name: pulumi.String("srcqueue"),
			RedrivePolicy: example.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON0, err := json.Marshal(map[string]interface{}{
					"deadLetterTargetArn": arn,
					"maxReceiveCount":     4,
				})
				if err != nil {
					return _zero, err
				}
				json0 := string(tmpJSON0)
				return pulumi.String(json0), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = sqs.NewRedriveAllowPolicy(ctx, "example", &sqs.RedriveAllowPolicyArgs{
			QueueUrl: example.ID(),
			RedriveAllowPolicy: src.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string]interface{}{
					"redrivePermission": "byQueue",
					"sourceQueueArns": []string{
						arn,
					},
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Sqs.Queue("example", new()
    {
        Name = "examplequeue",
    });

    var src = new Aws.Sqs.Queue("src", new()
    {
        Name = "srcqueue",
        RedrivePolicy = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["deadLetterTargetArn"] = example.Arn,
            ["maxReceiveCount"] = 4,
        })),
    });

    var exampleRedriveAllowPolicy = new Aws.Sqs.RedriveAllowPolicy("example", new()
    {
        QueueUrl = example.Id,
        RedriveAllowPolicyName = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["redrivePermission"] = "byQueue",
            ["sourceQueueArns"] = new[]
            {
                src.Arn,
            },
        })),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sqs.Queue;
import com.pulumi.aws.sqs.QueueArgs;
import com.pulumi.aws.sqs.RedriveAllowPolicy;
import com.pulumi.aws.sqs.RedriveAllowPolicyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
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) {
        var example = new Queue("example", QueueArgs.builder()
            .name("examplequeue")
            .build());

        var src = new Queue("src", QueueArgs.builder()
            .name("srcqueue")
            .redrivePolicy(example.arn().applyValue(_arn -> serializeJson(
                jsonObject(
                    jsonProperty("deadLetterTargetArn", _arn),
                    jsonProperty("maxReceiveCount", 4)
                ))))
            .build());

        var exampleRedriveAllowPolicy = new RedriveAllowPolicy("exampleRedriveAllowPolicy", RedriveAllowPolicyArgs.builder()
            .queueUrl(example.id())
            .redriveAllowPolicy(src.arn().applyValue(_arn -> serializeJson(
                jsonObject(
                    jsonProperty("redrivePermission", "byQueue"),
                    jsonProperty("sourceQueueArns", jsonArray(_arn))
                ))))
            .build());

    }
}

resources:
  src:
    type: aws:sqs:Queue
    properties:
      name: srcqueue
      redrivePolicy:
        fn::toJSON:
          deadLetterTargetArn: ${example.arn}
          maxReceiveCount: 4
  example:
    type: aws:sqs:Queue
    properties:
      name: examplequeue
  exampleRedriveAllowPolicy:
    type: aws:sqs:RedriveAllowPolicy
    name: example
    properties:
      queueUrl: ${example.id}
      redriveAllowPolicy:
        fn::toJSON:
          redrivePermission: byQueue
          sourceQueueArns:
            - ${src.arn}

var redriveAllowPolicyResource = new Aws.Sqs.RedriveAllowPolicy("redriveAllowPolicyResource", new()
{
    QueueUrl = "string",
    RedriveAllowPolicyName = "string",
});

example, err := sqs.NewRedriveAllowPolicy(ctx, "redriveAllowPolicyResource", &sqs.RedriveAllowPolicyArgs{
	QueueUrl:           pulumi.String("string"),
	RedriveAllowPolicy: pulumi.String("string"),
})

var redriveAllowPolicyResource = new RedriveAllowPolicy("redriveAllowPolicyResource", RedriveAllowPolicyArgs.builder()
    .queueUrl("string")
    .redriveAllowPolicy("string")
    .build());

redrive_allow_policy_resource = aws.sqs.RedriveAllowPolicy("redriveAllowPolicyResource",
    queue_url="string",
    redrive_allow_policy="string")

type: aws:sqs:RedriveAllowPolicy
properties:
    queueUrl: string
    redriveAllowPolicy: string