Bilal's Blog
Managing EC2 Instances in Go: Waiting for the Instance to Start Running

Managing EC2 Instances in Go: Waiting for the Instance to Start Running

Making Sure Your AWS EC2 Instance Is Running Properly with Go

Bilal Khan's photo
Bilal Khan
·

4 min read

Table of contents

Intro 😊

As a software developer, I always look for efficient ways to solve problems, and AWS is an excellent platform that offers endless possibilities to achieve this.

Yesterday, I worked on creating an EC2 instance in Go using the AWS SDK for Go. AWS EC2 instances are a popular choice for hosting applications and being able to create and manage them programmatically is essential.

Today's work 📝

Today I am going to work on the waitUntilInstanceRunning() function, which enables you to wait for an instance to start running before proceeding with any further actions, making it a crucial part of the process. In this blog,

I'll explain in detail how this function works and how you can use it to ensure that your EC2 instance is running correctly. So, if you're curious to learn about managing EC2 instances in Go, keep reading!

Important Note 🤔

This blog post does not cover the implementation of the createEC2Instance() function. I have discussed all these things in my previous blog.

It solely focuses on explaining the waitUntilInstanceRunning() function and how it can be used to wait for a specified EC2 instance to be in the "running" state.

Here is a video about this topic 🚀

https://www.youtube.com/watch?v=54gGVjaZ57Y

Now let's dive into the code and understand how it works.

Import Required Packages 📦

First, we need to import the required packages for working with the AWS SDK for Go and the EC2 service.

import (
    "fmt"
    "log"
    "os"
    "time"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/ec2"
)

Define the Wait Until Instance Running Function 🔥

Next, we define the waitUntilInstanceRunning() function. This function takes two parameters: the svc parameter, which is a pointer to an EC2 service client, and the instanceID parameter, which is a string that contains the ID of the EC2 instance that we want to check the status of.

func waitUntilInstanceRunning(svc *ec2.EC2, instanceID string) error {
  // function code
}

The function returns an error if the instance doesn't reach the "running" state within a certain period of time or if there is an error communicating with the EC2 service.

Create a Describe Instances Input 🗣️

We create an input object of the type ec2.DescribeInstancesInput(), which will be used to describe the specified EC2 instance.

input := &ec2.DescribeInstancesInput{
  InstanceIds: []*string{aws.String(instanceID)},
}

Here, we create an instance of ec2.DescribeInstancesInput() and set the InstanceIds field to an array that contains a single element, which is a pointer to a string containing the instance ID that we want to describe.

Call Wait Until Instance Running Function 🤙

Now, we call the WaitUntilInstanceRunning() function on the svc object, passing in the input object we created in the previous step.

err := svc.WaitUntilInstanceRunning(input)

Check for Errors 😕

After calling the WaitUntilInstanceRunning() function, We check if there was an error by examining the err variable.

if err != nil {
  return err
}

If there was an error, we return it immediately. Otherwise, we print a message to indicate that the instance is now running.

Print a Message Indicating the Instance is Running 🤗

If there was no error, we print a message to indicate that the instance is now running.

fmt.Printf("EC2 instance with ID %s is running\n", instanceID)

This line prints a message to the console, indicating that the EC2 instance with the specified ID is now running.

Return nil if There Was No Error 💡

Finally, we return nil to indicate that there was no error.

return nil

This line returns nil to indicate that the function was executed successfully and that the EC2 instance with the specified ID is now running.

Call the Wait Until Instance in the main function 🎈

After creating the function, we need to call this function in the main function also. To do this, you need to provide two arguments. One is serviceClient and another is instanceID.

err = waitUntilInstanceRunning(serviceClient, instanceID)
if err != nil {
    log.Fatalf("failed to run an EC2 instance %v", err)
}

Repo 🎁

The code that I have shown you in this blog is present in this repository.

Conclusion 🙋‍♀️

In conclusion, the waitUntilInstanceRunning() function uses the AWS SDK for Go to wait until a specified EC2 instance is in the "running" state.

By using this function, developers can ensure that their Go programs interact with the EC2 service effectively and efficiently.

That's it for now. Did you like this blog? Please let me know.

You can Buy Me a Coffee if you want to and please don't forget to follow me on YouTube, Twitter, and LinkedIn also.

Happy Learning!

AWSKubernetesBloggingcommunityinstance