Association class

Associates an SSM Document to an instance or EC2 tag.

Example Usage

Create an association for a specific instance

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

const example = new aws.ssm.Association("example", {
    targets: [{
        key: "InstanceIds",
        values: [exampleAwsInstance.id],
    }],
    name: exampleAwsSsmDocument.name,
});
import pulumi
import pulumi_aws as aws

example = aws.ssm.Association("example",
    targets=[{
        "key": "InstanceIds",
        "values": [example_aws_instance["id"]],
    }],
    name=example_aws_ssm_document["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ssm.Association("example", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "InstanceIds",
                Values = new[]
                {
                    exampleAwsInstance.Id,
                },
            },
        },
        Name = exampleAwsSsmDocument.Name,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ssm.NewAssociation(ctx, "example", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("InstanceIds"),
					Values: pulumi.StringArray{
						exampleAwsInstance.Id,
					},
				},
			},
			Name: pulumi.Any(exampleAwsSsmDocument.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ssm_association" "example" {
  targets {
    key    = "InstanceIds"
    values = [exampleAwsInstance.id]
  }
  name = exampleAwsSsmDocument.name
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
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) {
        var example = new Association("example", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("InstanceIds")
                .values(exampleAwsInstance.id())
                .build())
            .name(exampleAwsSsmDocument.name())
            .build());

    }
}
resources:
  example:
    type: aws:ssm:Association
    properties:
      targets:
        - key: InstanceIds
          values:
            - ${exampleAwsInstance.id}
      name: ${exampleAwsSsmDocument.name}

Create an association for all managed instances in an AWS account

To target all managed instances in an AWS account, set the key as "InstanceIds" with values set as ["*"]. This example also illustrates how to use an Amazon owned SSM document named AmazonCloudWatch-ManageAgent.

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

const example = new aws.ssm.Association("example", {
    targets: [{
        key: "InstanceIds",
        values: ["*"],
    }],
    name: "AmazonCloudWatch-ManageAgent",
});
import pulumi
import pulumi_aws as aws

example = aws.ssm.Association("example",
    targets=[{
        "key": "InstanceIds",
        "values": ["*"],
    }],
    name="AmazonCloudWatch-ManageAgent")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ssm.Association("example", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "InstanceIds",
                Values = new[]
                {
                    "*",
                },
            },
        },
        Name = "AmazonCloudWatch-ManageAgent",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ssm.NewAssociation(ctx, "example", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("InstanceIds"),
					Values: pulumi.StringArray{
						pulumi.String("*"),
					},
				},
			},
			Name: pulumi.String("AmazonCloudWatch-ManageAgent"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ssm_association" "example" {
  targets {
    key    = "InstanceIds"
    values = ["*"]
  }
  name = "AmazonCloudWatch-ManageAgent"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
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) {
        var example = new Association("example", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("InstanceIds")
                .values("*")
                .build())
            .name("AmazonCloudWatch-ManageAgent")
            .build());

    }
}
resources:
  example:
    type: aws:ssm:Association
    properties:
      targets:
        - key: InstanceIds
          values:
            - '*'
      name: AmazonCloudWatch-ManageAgent

Create an association for a specific tag

This example shows how to target all managed instances that are assigned a tag key of Environment and value of Development.

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

const example = new aws.ssm.Association("example", {
    targets: [{
        key: "tag:Environment",
        values: ["Development"],
    }],
    name: "AmazonCloudWatch-ManageAgent",
});
import pulumi
import pulumi_aws as aws

example = aws.ssm.Association("example",
    targets=[{
        "key": "tag:Environment",
        "values": ["Development"],
    }],
    name="AmazonCloudWatch-ManageAgent")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ssm.Association("example", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "tag:Environment",
                Values = new[]
                {
                    "Development",
                },
            },
        },
        Name = "AmazonCloudWatch-ManageAgent",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ssm.NewAssociation(ctx, "example", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("tag:Environment"),
					Values: pulumi.StringArray{
						pulumi.String("Development"),
					},
				},
			},
			Name: pulumi.String("AmazonCloudWatch-ManageAgent"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ssm_association" "example" {
  targets {
    key    = "tag:Environment"
    values = ["Development"]
  }
  name = "AmazonCloudWatch-ManageAgent"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
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) {
        var example = new Association("example", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("tag:Environment")
                .values("Development")
                .build())
            .name("AmazonCloudWatch-ManageAgent")
            .build());

    }
}
resources:
  example:
    type: aws:ssm:Association
    properties:
      targets:
        - key: tag:Environment
          values:
            - Development
      name: AmazonCloudWatch-ManageAgent

Create an association with a specific schedule

This example shows how to schedule an association in various ways.

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

const example = new aws.ssm.Association("example", {
    targets: [{
        key: "InstanceIds",
        values: [exampleAwsInstance.id],
    }],
    name: exampleAwsSsmDocument.name,
    scheduleExpression: "cron(0 2 ? * SUN *)",
});
import pulumi
import pulumi_aws as aws

example = aws.ssm.Association("example",
    targets=[{
        "key": "InstanceIds",
        "values": [example_aws_instance["id"]],
    }],
    name=example_aws_ssm_document["name"],
    schedule_expression="cron(0 2 ? * SUN *)")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ssm.Association("example", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "InstanceIds",
                Values = new[]
                {
                    exampleAwsInstance.Id,
                },
            },
        },
        Name = exampleAwsSsmDocument.Name,
        ScheduleExpression = "cron(0 2 ? * SUN *)",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ssm.NewAssociation(ctx, "example", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("InstanceIds"),
					Values: pulumi.StringArray{
						exampleAwsInstance.Id,
					},
				},
			},
			Name:               pulumi.Any(exampleAwsSsmDocument.Name),
			ScheduleExpression: pulumi.String("cron(0 2 ? * SUN *)"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ssm_association" "example" {
  targets {
    key    = "InstanceIds"
    values = [exampleAwsInstance.id]
  }
  name                = exampleAwsSsmDocument.name
  schedule_expression = "cron(0 2 ? * SUN *)"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
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) {
        var example = new Association("example", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("InstanceIds")
                .values(exampleAwsInstance.id())
                .build())
            .name(exampleAwsSsmDocument.name())
            .scheduleExpression("cron(0 2 ? * SUN *)")
            .build());

    }
}
resources:
  example:
    type: aws:ssm:Association
    properties:
      targets:
        - key: InstanceIds
          values:
            - ${exampleAwsInstance.id}
      name: ${exampleAwsSsmDocument.name}
      scheduleExpression: cron(0 2 ? * SUN *)

Create an association with multiple instances with their instance ids

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

// First EC2 instance
const webServer1 = new aws.ec2.Instance("web_server_1", {
    ami: amazonLinux.id,
    instanceType: aws.ec2.InstanceType.T3_Micro,
    subnetId: _public.id,
    vpcSecurityGroupIds: [ec2Sg.id],
    iamInstanceProfile: ec2SsmProfile.name,
    userData: `#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
`,
});
// Second EC2 instance
const webServer2 = new aws.ec2.Instance("web_server_2", {
    ami: amazonLinux.id,
    instanceType: aws.ec2.InstanceType.T3_Micro,
    subnetId: _public.id,
    vpcSecurityGroupIds: [ec2Sg.id],
    iamInstanceProfile: ec2SsmProfile.name,
    userData: `#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
`,
});
// Removed EC2 provisioning dependencies for brevity
const systemUpdate = new aws.ssm.Association("system_update", {
    targets: [{
        key: "InstanceIds",
        values: [
            webServer1.id,
            webServer2.id,
        ],
    }],
    name: "AWS-RunShellScript",
    scheduleExpression: "cron(0 2 ? * SUN *)",
    parameters: {
        commands: std.join({
            separator: "\n",
            input: [
                "#!/bin/bash",
                "echo 'Starting system update on $(hostname)'",
                "echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'",
                "yum update -y",
                "echo 'System update completed successfully'",
                "systemctl status httpd",
                "df -h",
                "free -m",
            ],
        }).then(invoke => invoke.result),
        workingDirectory: "/tmp",
        executionTimeout: "3600",
    },
    associationName: "weekly-system-update",
    complianceSeverity: "MEDIUM",
    maxConcurrency: "1",
    maxErrors: "0",
    tags: {
        Name: "Weekly System Update",
        Environment: "demo",
        Purpose: "maintenance",
    },
});
import pulumi
import pulumi_aws as aws
import pulumi_std as std

# First EC2 instance
web_server1 = aws.ec2.Instance("web_server_1",
    ami=amazon_linux["id"],
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    subnet_id=public["id"],
    vpc_security_group_ids=[ec2_sg["id"]],
    iam_instance_profile=ec2_ssm_profile["name"],
    user_data="""#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
""")
# Second EC2 instance
web_server2 = aws.ec2.Instance("web_server_2",
    ami=amazon_linux["id"],
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    subnet_id=public["id"],
    vpc_security_group_ids=[ec2_sg["id"]],
    iam_instance_profile=ec2_ssm_profile["name"],
    user_data="""#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
""")
# Removed EC2 provisioning dependencies for brevity
system_update = aws.ssm.Association("system_update",
    targets=[{
        "key": "InstanceIds",
        "values": [
            web_server1.id,
            web_server2.id,
        ],
    }],
    name="AWS-RunShellScript",
    schedule_expression="cron(0 2 ? * SUN *)",
    parameters={
        "commands": std.join(separator="\n",
            input=[
                "#!/bin/bash",
                "echo 'Starting system update on $(hostname)'",
                "echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'",
                "yum update -y",
                "echo 'System update completed successfully'",
                "systemctl status httpd",
                "df -h",
                "free -m",
            ]).result,
        "workingDirectory": "/tmp",
        "executionTimeout": "3600",
    },
    association_name="weekly-system-update",
    compliance_severity="MEDIUM",
    max_concurrency="1",
    max_errors="0",
    tags={
        "Name": "Weekly System Update",
        "Environment": "demo",
        "Purpose": "maintenance",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() =>
{
    // First EC2 instance
    var webServer1 = new Aws.Ec2.Instance("web_server_1", new()
    {
        Ami = amazonLinux.Id,
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        SubnetId = @public.Id,
        VpcSecurityGroupIds = new[]
        {
            ec2Sg.Id,
        },
        IamInstanceProfile = ec2SsmProfile.Name,
        UserData = @"#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
",
    });

    // Second EC2 instance
    var webServer2 = new Aws.Ec2.Instance("web_server_2", new()
    {
        Ami = amazonLinux.Id,
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        SubnetId = @public.Id,
        VpcSecurityGroupIds = new[]
        {
            ec2Sg.Id,
        },
        IamInstanceProfile = ec2SsmProfile.Name,
        UserData = @"#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
",
    });

    // Removed EC2 provisioning dependencies for brevity
    var systemUpdate = new Aws.Ssm.Association("system_update", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "InstanceIds",
                Values = new[]
                {
                    webServer1.Id,
                    webServer2.Id,
                },
            },
        },
        Name = "AWS-RunShellScript",
        ScheduleExpression = "cron(0 2 ? * SUN *)",
        Parameters =
        {
            { "commands", Std.Join.Invoke(new()
            {
                Separator = @"
",
                Input = new[]
                {
                    "#!/bin/bash",
                    "echo 'Starting system update on $(hostname)'",
                    "echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'",
                    "yum update -y",
                    "echo 'System update completed successfully'",
                    "systemctl status httpd",
                    "df -h",
                    "free -m",
                },
            }).Apply(invoke => invoke.Result) },
            { "workingDirectory", "/tmp" },
            { "executionTimeout", "3600" },
        },
        AssociationName = "weekly-system-update",
        ComplianceSeverity = "MEDIUM",
        MaxConcurrency = "1",
        MaxErrors = "0",
        Tags =
        {
            { "Name", "Weekly System Update" },
            { "Environment", "demo" },
            { "Purpose", "maintenance" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// First EC2 instance
		webServer1, err := ec2.NewInstance(ctx, "web_server_1", &ec2.InstanceArgs{
			Ami:          pulumi.Any(amazonLinux.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			SubnetId:     pulumi.Any(public.Id),
			VpcSecurityGroupIds: pulumi.StringArray{
				ec2Sg.Id,
			},
			IamInstanceProfile: pulumi.Any(ec2SsmProfile.Name),
			UserData: pulumi.String(`#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
`),
		})
		if err != nil {
			return err
		}
		// Second EC2 instance
		webServer2, err := ec2.NewInstance(ctx, "web_server_2", &ec2.InstanceArgs{
			Ami:          pulumi.Any(amazonLinux.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			SubnetId:     pulumi.Any(public.Id),
			VpcSecurityGroupIds: pulumi.StringArray{
				ec2Sg.Id,
			},
			IamInstanceProfile: pulumi.Any(ec2SsmProfile.Name),
			UserData: pulumi.String(`#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
`),
		})
		if err != nil {
			return err
		}
		invokeJoin, err := std.Join(ctx, &std.JoinArgs{
			Separator: "\n",
			Input: []string{
				"#!/bin/bash",
				"echo 'Starting system update on $(hostname)'",
				"echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'",
				"yum update -y",
				"echo 'System update completed successfully'",
				"systemctl status httpd",
				"df -h",
				"free -m",
			},
		}, nil)
		if err != nil {
			return err
		}
		// Removed EC2 provisioning dependencies for brevity
		_, err = ssm.NewAssociation(ctx, "system_update", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("InstanceIds"),
					Values: pulumi.StringArray{
						webServer1.ID().ToIDOutput().ToStringOutput(),
						webServer2.ID().ToIDOutput().ToStringOutput(),
					},
				},
			},
			Name:               pulumi.String("AWS-RunShellScript"),
			ScheduleExpression: pulumi.String("cron(0 2 ? * SUN *)"),
			Parameters: pulumi.StringMap{
				"commands":         pulumi.String(invokeJoin.Result),
				"workingDirectory": pulumi.String("/tmp"),
				"executionTimeout": pulumi.String("3600"),
			},
			AssociationName:    pulumi.String("weekly-system-update"),
			ComplianceSeverity: pulumi.String("MEDIUM"),
			MaxConcurrency:     pulumi.String("1"),
			MaxErrors:          pulumi.String("0"),
			Tags: pulumi.StringMap{
				"Name":        pulumi.String("Weekly System Update"),
				"Environment": pulumi.String("demo"),
				"Purpose":     pulumi.String("maintenance"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

# Removed EC2 provisioning dependencies for brevity
resource "aws_ssm_association" "system_update" {
  targets {
    key    = "InstanceIds"
    values = [aws_ec2_instance.web_server_1.id, aws_ec2_instance.web_server_2.id]
  }
  name                = "AWS-RunShellScript"
  schedule_expression = "cron(0 2 ? * SUN *)"
  parameters = {
    "commands"         = join("\n", ["#!/bin/bash", "echo 'Starting system update on $(hostname)'", "echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'", "yum update -y", "echo 'System update completed successfully'", "systemctl status httpd", "df -h", "free -m"])
    "workingDirectory" = "/tmp"
    "executionTimeout" = "3600"
  }
  association_name    = "weekly-system-update"
  compliance_severity = "MEDIUM"
  max_concurrency     = "1"
  max_errors          = "0"
  tags = {
    "Name"        = "Weekly System Update"
    "Environment" = "demo"
    "Purpose"     = "maintenance"
  }
}
# First EC2 instance
resource "aws_ec2_instance" "web_server_1" {
  ami                    = amazonLinux.id
  instance_type          = "t3.micro"
  subnet_id              = public.id
  vpc_security_group_ids = [ec2Sg.id]
  iam_instance_profile   = ec2SsmProfile.name
  user_data              = "#!/bin/bash\nyum update -y\nyum install -y amazon-ssm-agent\nsystemctl enable amazon-ssm-agent\nsystemctl start amazon-ssm-agent\n"
}
# Second EC2 instance
resource "aws_ec2_instance" "web_server_2" {
  ami                    = amazonLinux.id
  instance_type          = "t3.micro"
  subnet_id              = public.id
  vpc_security_group_ids = [ec2Sg.id]
  iam_instance_profile   = ec2SsmProfile.name
  user_data              = "#!/bin/bash\nyum update -y\nyum install -y amazon-ssm-agent\nsystemctl enable amazon-ssm-agent\nsystemctl start amazon-ssm-agent\n"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.JoinArgs;
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) {
        // First EC2 instance
        var webServer1 = new Instance("webServer1", InstanceArgs.builder()
            .ami(amazonLinux.id())
            .instanceType("t3.micro")
            .subnetId(public_.id())
            .vpcSecurityGroupIds(ec2Sg.id())
            .iamInstanceProfile(ec2SsmProfile.name())
            .userData("""
#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
            """)
            .build());

        // Second EC2 instance
        var webServer2 = new Instance("webServer2", InstanceArgs.builder()
            .ami(amazonLinux.id())
            .instanceType("t3.micro")
            .subnetId(public_.id())
            .vpcSecurityGroupIds(ec2Sg.id())
            .iamInstanceProfile(ec2SsmProfile.name())
            .userData("""
#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent
            """)
            .build());

        // Removed EC2 provisioning dependencies for brevity
        var systemUpdate = new Association("systemUpdate", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("InstanceIds")
                .values(
                    webServer1.id(),
                    webServer2.id())
                .build())
            .name("AWS-RunShellScript")
            .scheduleExpression("cron(0 2 ? * SUN *)")
            .parameters(Map.ofEntries(
                Map.entry("commands", StdFunctions.join(JoinArgs.builder()
                    .separator("""

                    """)
                    .input(
                        "#!/bin/bash",
                        "echo 'Starting system update on $(hostname)'",
                        "echo 'Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'",
                        "yum update -y",
                        "echo 'System update completed successfully'",
                        "systemctl status httpd",
                        "df -h",
                        "free -m")
                    .build()).result()),
                Map.entry("workingDirectory", "/tmp"),
                Map.entry("executionTimeout", "3600")
            ))
            .associationName("weekly-system-update")
            .complianceSeverity("MEDIUM")
            .maxConcurrency("1")
            .maxErrors("0")
            .tags(Map.ofEntries(
                Map.entry("Name", "Weekly System Update"),
                Map.entry("Environment", "demo"),
                Map.entry("Purpose", "maintenance")
            ))
            .build());

    }
}
resources:
  # Removed EC2 provisioning dependencies for brevity
  systemUpdate:
    type: aws:ssm:Association
    name: system_update
    properties:
      targets:
        - key: InstanceIds
          values:
            - ${webServer1.id}
            - ${webServer2.id}
      name: AWS-RunShellScript
      scheduleExpression: cron(0 2 ? * SUN *)
      parameters:
        commands:
          fn::invoke:
            function: std:join
            arguments:
              separator: |2+
              input:
                - '#!/bin/bash'
                - echo 'Starting system update on $(hostname)'
                - 'echo ''Instance ID: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)'''
                - yum update -y
                - echo 'System update completed successfully'
                - systemctl status httpd
                - df -h
                - free -m
            return: result
        workingDirectory: /tmp
        executionTimeout: '3600'
      associationName: weekly-system-update
      complianceSeverity: MEDIUM
      maxConcurrency: '1'
      maxErrors: '0'
      tags:
        Name: Weekly System Update
        Environment: demo
        Purpose: maintenance
  # First EC2 instance
  webServer1:
    type: aws:ec2:Instance
    name: web_server_1
    properties:
      ami: ${amazonLinux.id}
      instanceType: t3.micro
      subnetId: ${public.id}
      vpcSecurityGroupIds:
        - ${ec2Sg.id}
      iamInstanceProfile: ${ec2SsmProfile.name}
      userData: |
        #!/bin/bash
        yum update -y
        yum install -y amazon-ssm-agent
        systemctl enable amazon-ssm-agent
        systemctl start amazon-ssm-agent
  # Second EC2 instance
  webServer2:
    type: aws:ec2:Instance
    name: web_server_2
    properties:
      ami: ${amazonLinux.id}
      instanceType: t3.micro
      subnetId: ${public.id}
      vpcSecurityGroupIds:
        - ${ec2Sg.id}
      iamInstanceProfile: ${ec2SsmProfile.name}
      userData: |
        #!/bin/bash
        yum update -y
        yum install -y amazon-ssm-agent
        systemctl enable amazon-ssm-agent
        systemctl start amazon-ssm-agent

Create an association with multiple instances with their values matching their tags

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

// SSM Association for Webbased Servers
const databaseAssociation = new aws.ssm.Association("database_association", {
    targets: [{
        key: "tag:Role",
        values: [
            "WebServer",
            "Database",
        ],
    }],
    name: systemUpdate.name,
    parameters: {
        restartServices: "true",
    },
    scheduleExpression: "cron(0 3 ? * SUN *)",
});
// EC2 Instance 1 - Web Server with "ServerType" tag
const webServer = new aws.ec2.Instance("web_server", {
    ami: amazonLinux.id,
    instanceType: aws.ec2.InstanceType.T3_Micro,
    subnetId: _default.id,
    vpcSecurityGroupIds: [ec2Sg.id],
    iamInstanceProfile: ec2SsmProfile.name,
    userData: std.base64encode({
        input: `#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \"<h1>Web Server - ${prefix}</h1>\" > /var/www/html/index.html
`,
    }).then(invoke => invoke.result),
    tags: {
        Name: `${prefix}-web-server`,
        ServerType: "WebServer",
        Role: "WebServer",
        Environment: environment,
        Owner: owner,
    },
});
// EC2 Instance 2 - Database Server with "Role" tag
const databaseServer = new aws.ec2.Instance("database_server", {
    ami: amazonLinux.id,
    instanceType: aws.ec2.InstanceType.T3_Micro,
    subnetId: _default.id,
    vpcSecurityGroupIds: [ec2Sg.id],
    iamInstanceProfile: ec2SsmProfile.name,
    userData: std.base64encode({
        input: `#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install MySQL
yum install -y mysql-server
systemctl enable mysqld
systemctl start mysqld
`,
    }).then(invoke => invoke.result),
    tags: {
        Name: `${prefix}-database-server`,
        Role: "Database",
        Environment: environment,
        Owner: owner,
    },
});
import pulumi
import pulumi_aws as aws
import pulumi_std as std

# SSM Association for Webbased Servers
database_association = aws.ssm.Association("database_association",
    targets=[{
        "key": "tag:Role",
        "values": [
            "WebServer",
            "Database",
        ],
    }],
    name=system_update["name"],
    parameters={
        "restartServices": "true",
    },
    schedule_expression="cron(0 3 ? * SUN *)")
# EC2 Instance 1 - Web Server with "ServerType" tag
web_server = aws.ec2.Instance("web_server",
    ami=amazon_linux["id"],
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    subnet_id=default["id"],
    vpc_security_group_ids=[ec2_sg["id"]],
    iam_instance_profile=ec2_ssm_profile["name"],
    user_data=std.base64encode(input=f"""#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \"<h1>Web Server - {prefix}</h1>\" > /var/www/html/index.html
""").result,
    tags={
        "Name": f"{prefix}-web-server",
        "ServerType": "WebServer",
        "Role": "WebServer",
        "Environment": environment,
        "Owner": owner,
    })
# EC2 Instance 2 - Database Server with "Role" tag
database_server = aws.ec2.Instance("database_server",
    ami=amazon_linux["id"],
    instance_type=aws.ec2.InstanceType.T3_MICRO,
    subnet_id=default["id"],
    vpc_security_group_ids=[ec2_sg["id"]],
    iam_instance_profile=ec2_ssm_profile["name"],
    user_data=std.base64encode(input="""#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install MySQL
yum install -y mysql-server
systemctl enable mysqld
systemctl start mysqld
""").result,
    tags={
        "Name": f"{prefix}-database-server",
        "Role": "Database",
        "Environment": environment,
        "Owner": owner,
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() =>
{
    // SSM Association for Webbased Servers
    var databaseAssociation = new Aws.Ssm.Association("database_association", new()
    {
        Targets = new[]
        {
            new Aws.Ssm.Inputs.AssociationTargetArgs
            {
                Key = "tag:Role",
                Values = new[]
                {
                    "WebServer",
                    "Database",
                },
            },
        },
        Name = systemUpdate.Name,
        Parameters =
        {
            { "restartServices", "true" },
        },
        ScheduleExpression = "cron(0 3 ? * SUN *)",
    });

    // EC2 Instance 1 - Web Server with "ServerType" tag
    var webServer = new Aws.Ec2.Instance("web_server", new()
    {
        Ami = amazonLinux.Id,
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        SubnetId = @default.Id,
        VpcSecurityGroupIds = new[]
        {
            ec2Sg.Id,
        },
        IamInstanceProfile = ec2SsmProfile.Name,
        UserData = Std.Base64encode.Invoke(new()
        {
            Input = @$"#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \""<h1>Web Server - {prefix}</h1>\"" > /var/www/html/index.html
",
        }).Apply(invoke => invoke.Result),
        Tags =
        {
            { "Name", $"{prefix}-web-server" },
            { "ServerType", "WebServer" },
            { "Role", "WebServer" },
            { "Environment", environment },
            { "Owner", owner },
        },
    });

    // EC2 Instance 2 - Database Server with "Role" tag
    var databaseServer = new Aws.Ec2.Instance("database_server", new()
    {
        Ami = amazonLinux.Id,
        InstanceType = Aws.Ec2.InstanceType.T3_Micro,
        SubnetId = @default.Id,
        VpcSecurityGroupIds = new[]
        {
            ec2Sg.Id,
        },
        IamInstanceProfile = ec2SsmProfile.Name,
        UserData = Std.Base64encode.Invoke(new()
        {
            Input = @"#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install MySQL
yum install -y mysql-server
systemctl enable mysqld
systemctl start mysqld
",
        }).Apply(invoke => invoke.Result),
        Tags =
        {
            { "Name", $"{prefix}-database-server" },
            { "Role", "Database" },
            { "Environment", environment },
            { "Owner", owner },
        },
    });

});
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ssm"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// SSM Association for Webbased Servers
		_, err := ssm.NewAssociation(ctx, "database_association", &ssm.AssociationArgs{
			Targets: ssm.AssociationTargetArray{
				&ssm.AssociationTargetArgs{
					Key: pulumi.String("tag:Role"),
					Values: pulumi.StringArray{
						pulumi.String("WebServer"),
						pulumi.String("Database"),
					},
				},
			},
			Name: pulumi.Any(systemUpdate.Name),
			Parameters: pulumi.StringMap{
				"restartServices": pulumi.String("true"),
			},
			ScheduleExpression: pulumi.String("cron(0 3 ? * SUN *)"),
		})
		if err != nil {
			return err
		}
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: fmt.Sprintf(`#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \"<h1>Web Server - %v</h1>\" > /var/www/html/index.html
`, prefix),
		}, nil)
		if err != nil {
			return err
		}
		// EC2 Instance 1 - Web Server with "ServerType" tag
		_, err = ec2.NewInstance(ctx, "web_server", &ec2.InstanceArgs{
			Ami:          pulumi.Any(amazonLinux.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			SubnetId:     pulumi.Any(_default.Id),
			VpcSecurityGroupIds: pulumi.StringArray{
				ec2Sg.Id,
			},
			IamInstanceProfile: pulumi.Any(ec2SsmProfile.Name),
			UserData:           pulumi.String(invokeBase64encode.Result),
			Tags: pulumi.StringMap{
				"Name":        pulumi.Sprintf("%v-web-server", prefix),
				"ServerType":  pulumi.String("WebServer"),
				"Role":        pulumi.String("WebServer"),
				"Environment": pulumi.Any(environment),
				"Owner":       pulumi.Any(owner),
			},
		})
		if err != nil {
			return err
		}
		invokeBase64encode1, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: `#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install MySQL
yum install -y mysql-server
systemctl enable mysqld
systemctl start mysqld
`,
		}, nil)
		if err != nil {
			return err
		}
		// EC2 Instance 2 - Database Server with "Role" tag
		_, err = ec2.NewInstance(ctx, "database_server", &ec2.InstanceArgs{
			Ami:          pulumi.Any(amazonLinux.Id),
			InstanceType: pulumi.String(ec2.InstanceType_T3_Micro),
			SubnetId:     pulumi.Any(_default.Id),
			VpcSecurityGroupIds: pulumi.StringArray{
				ec2Sg.Id,
			},
			IamInstanceProfile: pulumi.Any(ec2SsmProfile.Name),
			UserData:           pulumi.String(invokeBase64encode1.Result),
			Tags: pulumi.StringMap{
				"Name":        pulumi.Sprintf("%v-database-server", prefix),
				"Role":        pulumi.String("Database"),
				"Environment": pulumi.Any(environment),
				"Owner":       pulumi.Any(owner),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

# SSM Association for Webbased Servers
resource "aws_ssm_association" "database_association" {
  targets {
    key    = "tag:Role"
    values = ["WebServer", "Database"]
  }
  name = systemUpdate.name
  parameters = {
    "restartServices" = "true"
  }
  schedule_expression = "cron(0 3 ? * SUN *)"
}
# EC2 Instance 1 - Web Server with "ServerType" tag
resource "aws_ec2_instance" "web_server" {
  ami                    = amazonLinux.id
  instance_type          = "t3.micro"
  subnet_id              = default.id
  vpc_security_group_ids = [ec2Sg.id]
  iam_instance_profile   = ec2SsmProfile.name
  user_data              = base64encode("#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \"<h1>Web Server - ${prefix}</h1>\" > /var/www/html/index.html
")
  tags = {
    "Name"        ="${prefix}-web-server"
    "ServerType"  = "WebServer"
    "Role"        = "WebServer"
    "Environment" = environment
    "Owner"       = owner
  }
}
# EC2 Instance 2 - Database Server with "Role" tag
resource "aws_ec2_instance" "database_server" {
  ami                    = amazonLinux.id
  instance_type          = "t3.micro"
  subnet_id              = default.id
  vpc_security_group_ids = [ec2Sg.id]
  iam_instance_profile   = ec2SsmProfile.name
  user_data              = base64encode("#!/bin/bash\nyum update -y\nyum install -y amazon-ssm-agent\nsystemctl enable amazon-ssm-agent\nsystemctl start amazon-ssm-agent\n    \n# Install MySQL\nyum install -y mysql-server\nsystemctl enable mysqld\nsystemctl start mysqld\n")
  tags = {
    "Name"        ="${prefix}-database-server"
    "Role"        = "Database"
    "Environment" = environment
    "Owner"       = owner
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ssm.Association;
import com.pulumi.aws.ssm.AssociationArgs;
import com.pulumi.aws.ssm.inputs.AssociationTargetArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Base64encodeArgs;
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) {
        // SSM Association for Webbased Servers
        var databaseAssociation = new Association("databaseAssociation", AssociationArgs.builder()
            .targets(AssociationTargetArgs.builder()
                .key("tag:Role")
                .values(
                    "WebServer",
                    "Database")
                .build())
            .name(systemUpdate.name())
            .parameters(Map.of("restartServices", "true"))
            .scheduleExpression("cron(0 3 ? * SUN *)")
            .build());

        // EC2 Instance 1 - Web Server with "ServerType" tag
        var webServer = new Instance("webServer", InstanceArgs.builder()
            .ami(amazonLinux.id())
            .instanceType("t3.micro")
            .subnetId(default_.id())
            .vpcSecurityGroupIds(ec2Sg.id())
            .iamInstanceProfile(ec2SsmProfile.name())
            .userData(StdFunctions.base64encode(Base64encodeArgs.builder()
                .input("""
#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install Apache web server
yum install -y httpd
systemctl enable httpd
systemctl start httpd
echo \"<h1>Web Server - %s</h1>\" > /var/www/html/index.html
", prefix))
                .build()).result())
            .tags(Map.ofEntries(
                Map.entry("Name", String.format("%s-web-server", prefix)),
                Map.entry("ServerType", "WebServer"),
                Map.entry("Role", "WebServer"),
                Map.entry("Environment", environment),
                Map.entry("Owner", owner)
            ))
            .build());

        // EC2 Instance 2 - Database Server with "Role" tag
        var databaseServer = new Instance("databaseServer", InstanceArgs.builder()
            .ami(amazonLinux.id())
            .instanceType("t3.micro")
            .subnetId(default_.id())
            .vpcSecurityGroupIds(ec2Sg.id())
            .iamInstanceProfile(ec2SsmProfile.name())
            .userData(StdFunctions.base64encode(Base64encodeArgs.builder()
                .input("""
#!/bin/bash
yum update -y
yum install -y amazon-ssm-agent
systemctl enable amazon-ssm-agent
systemctl start amazon-ssm-agent

# Install MySQL
yum install -y mysql-server
systemctl enable mysqld
systemctl start mysqld
                """)
                .build()).result())
            .tags(Map.ofEntries(
                Map.entry("Name", String.format("%s-database-server", prefix)),
                Map.entry("Role", "Database"),
                Map.entry("Environment", environment),
                Map.entry("Owner", owner)
            ))
            .build());

    }
}
resources:
  # SSM Association for Webbased Servers
  databaseAssociation:
    type: aws:ssm:Association
    name: database_association
    properties:
      targets:
        - key: tag:Role
          values:
            - WebServer
            - Database
      name: ${systemUpdate.name}
      parameters:
        restartServices: 'true'
      scheduleExpression: cron(0 3 ? * SUN *)
  # EC2 Instance 1 - Web Server with "ServerType" tag
  webServer:
    type: aws:ec2:Instance
    name: web_server
    properties:
      ami: ${amazonLinux.id}
      instanceType: t3.micro
      subnetId: ${default.id}
      vpcSecurityGroupIds:
        - ${ec2Sg.id}
      iamInstanceProfile: ${ec2SsmProfile.name}
      userData:
        fn::invoke:
          function: std:base64encode
          arguments:
            input: "#!/bin/bash\nyum update -y\nyum install -y amazon-ssm-agent\nsystemctl enable amazon-ssm-agent\nsystemctl start amazon-ssm-agent\n    \n# Install Apache web server\nyum install -y httpd\nsystemctl enable httpd\nsystemctl start httpd\necho \\\"<h1>Web Server - ${prefix}</h1>\\\" > /var/www/html/index.html\n"
          return: result
      tags:
        Name: ${prefix}-web-server
        ServerType: WebServer
        Role: WebServer
        Environment: ${environment}
        Owner: ${owner}
  # EC2 Instance 2 - Database Server with "Role" tag
  databaseServer:
    type: aws:ec2:Instance
    name: database_server
    properties:
      ami: ${amazonLinux.id}
      instanceType: t3.micro
      subnetId: ${default.id}
      vpcSecurityGroupIds:
        - ${ec2Sg.id}
      iamInstanceProfile: ${ec2SsmProfile.name}
      userData:
        fn::invoke:
          function: std:base64encode
          arguments:
            input: "#!/bin/bash\nyum update -y\nyum install -y amazon-ssm-agent\nsystemctl enable amazon-ssm-agent\nsystemctl start amazon-ssm-agent\n    \n# Install MySQL\nyum install -y mysql-server\nsystemctl enable mysqld\nsystemctl start mysqld\n"
          return: result
      tags:
        Name: ${prefix}-database-server
        Role: Database
        Environment: ${environment}
        Owner: ${owner}

Import

Identity Schema

Required

  • associationId - (String) ID of the SSM association.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import SSM associations using the associationId. For example:

$ pulumi import aws:ssm/association:Association example 10abcdef-0abc-1234-5678-90abcdef123456

Constructors

Association(String name, {AssociationArgs? args, CustomResourceOptions? options})
Creates a new Association. name The Pulumi resource name. args Arguments used to configure this Association. The set of arguments for Association. options Resource options controlling this resource's behavior.
Association.reference(String urn)
Creates a typed reference to an existing Association resource.

Properties

applyOnlyAtCronInterval ↔ Output<bool?>
By default, when you create a new or update associations, the system runs it immediately and then according to the schedule you specified. Enable this option if you do not want an association to run immediately after you create or update it. This parameter is not supported for rate expressions. Default: false.
latefinal
arn ↔ Output<String>
The ARN of the SSM association
latefinal
associationId ↔ Output<String>
The ID of the SSM association.
latefinal
associationName ↔ Output<String?>
The descriptive name for the association.
latefinal
automationTargetParameterName ↔ Output<String?>
Specify the target for the association. This target is required for associations that use an Automation document and target resources by using rate controls. This should be set to the SSM document parameter that will define how your automation will branch out.
latefinal
calendarNames ↔ Output<List<String>?>
One or more Systems Manager Change Calendar names. The association runs only when the Change Calendar is open.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
complianceSeverity ↔ Output<String?>
The compliance severity for the association. Can be one of the following: UNSPECIFIED, LOW, MEDIUM, HIGH or CRITICAL
latefinal
documentVersion ↔ Output<String>
The document version you want to associate with the target(s). Can be a specific version or the default version.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
maxConcurrency ↔ Output<String?>
The maximum number of targets allowed to run the association at the same time. You can specify a number, for example 10, or a percentage of the target set, for example 10%.
latefinal
maxErrors ↔ Output<String?>
The number of errors that are allowed before the system stops sending requests to run the association on additional targets. You can specify a number, for example 10, or a percentage of the target set, for example 10%. If you specify a threshold of 3, the stop command is sent when the fourth error is returned. If you specify a threshold of 10% for 50 associations, the stop command is sent when the sixth error is returned.
latefinal
name ↔ Output<String>
The name of the SSM document to apply.
latefinal
outputLocation ↔ Output<AssociationOutputLocation?>
An output location block. Output Location is documented below.
latefinal
parameters ↔ Output<Map<String, String>>
A block of arbitrary string parameters to pass to the SSM document.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
scheduleExpression ↔ Output<String?>
A cron or rate expression that specifies when the association runs.
latefinal
syncCompliance ↔ Output<String?>
The mode for generating association compliance. You can specify AUTO or MANUAL.
latefinal
tags ↔ Output<Map<String, String>?>
A map of tags to assign to the object. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
targets ↔ Output<List<AssociationTarget>>
A block containing the targets of the SSM association. Targets are documented below. AWS currently supports a maximum of 5 targets.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
waitForSuccessTimeoutSeconds ↔ Output<int?>
The number of seconds to wait for the association status to be Success. If Success status is not reached within the given time, create opration will fail.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AssociationState? state, CustomResourceOptions? options}) → Association
Gets an existing Association resource's state with the given name and id.