How can I send a shell command to an EC2 instance in Go

Question

Pulumi · Accepted Answer

To execute a shell command on an EC2 instance using Pulumi and Go, you'll want to utilize the EC2 instance's `userData` script for the initial setup or install a configuration management tool like Ansible, Chef, or Puppet to manage the instance. The `userData` script executes commands on the instance upon its first boot. This is an efficient way to run shell commands for initial configuration.

If you need to run commands after the instance has been created and initialized, you'd typically use SSH for communication with the instance. However, Pulumi does not natively manage runtime operations, and running such commands fall outside of Pulumi's scope as an infrastructure as code tool. Thus, you would typically handle these operations with external scripts or tools beyond the initial setup with `userData`.

Here's a simple Pulumi program in Go to create an AWS EC2 instance with a `userData` script that runs a shell command at startup:

```go
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Retrieve the AMI for Amazon Linux 2, in this case from the us-west-2 region.
		// Change this according to your preferred region.
		amiID, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			Filters: []ec2.LookupAmiFilter{{
				Name:   "name",
				Values: []string{"amzn2-ami-hvm-*-x86_64-gp2"},
			}},
			Owners: []string{"amazon"},
			MostRecent: pulumi.BoolRef(true),
		})
		if err != nil {
			return err
		}

// Retrieve the default VPC and subnet for your AWS account/region.
		vpc, err := ec2.LookupVpc(ctx, &ec2.LookupVpcArgs{
			Default: pulumi.BoolRef(true),
		})
		if err != nil {
			return err
		}

subnet, err := ec2.LookupSubnet(ctx, &ec2.LookupSubnetArgs{
			DefaultForAz: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}

// Create a new security group that allows SSH access.
		secGroup, err := ec2.NewSecurityGroup(ctx, "allowSsh", &ec2.SecurityGroupArgs{
			Description: pulumi.String("Allow SSH inbound traffic"),
			VpcId:       pulumi.String(vpc.Id),
			Ingress: ec2.SecurityGroupIngressArray{
				ec2.SecurityGroupIngressArgs{
					Description: pulumi.String("SSH access from anywhere"),
					FromPort:    pulumi.Int(22),
					ToPort:      pulumi.Int(22),
					Protocol:    pulumi.String("tcp"),
					CidrBlocks:  pulumi.StringArray{pulumi.String("0.0.0.0/0")},
				},
			},
		})
		if err != nil {
			return err
		}

// Specify the user data script to run a shell command.
		// In this case, we're updating the system and installing Apache.
		userData := `#!/bin/bash
		yum update -y
		yum install -y httpd
		service httpd start
		echo "Hello, World!" > /var/www/html/index.html
		`

// Create a new EC2 instance with the user data script.
		server, err := ec2.NewInstance(ctx, "web-server", &ec2.InstanceArgs{
			InstanceType:        pulumi.String("t2.micro"),
			VpcSecurityGroupIds: pulumi.StringArray{secGroup.ID()},
			Ami:                 pulumi.String(amiID.Id),
			SubnetId:            pulumi.String(subnet.Id),
			UserData:            pulumi.String(userData),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("web-server"),
			},
		})
		if err != nil {
			return err
		}

// Expose the public IP of the instance as a stack output.
		ctx.Export("publicIp", server.PublicIp)

return nil
	})
}
```

This Pulumi program sets up a simple web server that responds with "Hello, World!" when visited. The EC2 instance is provisioned with the AWS Linux 2 AMI in the `us-west-2` region, and the user data script updates the system, installs Apache HTTP Server, starts the web server, and places a file named `index.html` with the content "Hello, World!" in the web directory.

- The AMI ID is looked up using a filter for the needed image.
- A VPC and subnet are obtained, defaulting to the default ones provided by the AWS account.
- A security group is established to allow SSH access for the EC2 instance.
- The `instanceType`, `vpcSecurityGroupIds`, `ami`, `subnetId`, and `userData` attributes are specified to configure the instance correctly.
- The public IP is exported as a stack output for easy access.

Please note that this script will execute the shell commands only once at the launch time of the instance. If you need to execute shell commands later, you'll need to manually SSH into the instance or use a system management service like AWS Systems Manager. This approach outside the initial provisioning is not covered by Pulumi and requires separate tools and scripts to manage.