DEV Community: Caleb Yeboah

Automating the deployment of Docker Containers on Amazon EC2 with Infrastructure as Code (IaC) tool - Terraform

Caleb Yeboah — Mon, 13 Nov 2023 21:38:01 +0000

Introduction:

Docker has revolutionized the way applications are deployed and run, providing a lightweight and consistent environment across different platforms. Amazon EC2, a popular cloud computing service, allows users to deploy virtual servers in the cloud. In this guide, we'll walk you through the process of pulling a Docker image from Docker Hub and running a container on an EC2 instance using Infrastructure as Code (IaC).

Prerequisites:

Before you begin, ensure you have the following prerequisites in place:

An AWS account with the necessary permissions to create EC2 instances.
The AWS CLI installed on your local machine.
Terraform installed on your local machine.

Step 1: Create an EC2 Key Pair

To securely access your EC2 instance, you'll need an SSH key pair. If you don't have one, create a new key pair using the AWS Management Console or the AWS CLI.

aws ec2 create-key-pair --key-name YourKeyName --query 'KeyMaterial' --output text > YourKeyName.pem
chmod 400 YourKeyName.pem

Alternatively, you can use ssh-keygen to create the key-pair on your computer.

Generate SSH key pair

ssh-keygen -t rsa -b 2048 -f YourKeyName

Set appropriate permissions

chmod 400 YourKeyName

Replace YourKeyName with a preferred name for your key pair.

2. Create a main.tf file

touch main.tf

Update main.tf

Modify the aws_instance resource block in main.tf to include the key_name parameter:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }

  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "us-west-2"
}


resource "aws_vpc" "main" {
  cidr_block = var.vpc_cidr_block

  tags = {
    "Name" = "Production ${var.main_vpc_name}"
  }
}

# Create a subnet
resource "aws_subnet" "web" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = var.web_subnet
  availability_zone = var.subnet_zone

  tags = {
    Name = "Web Subnet"
  }
}


resource "aws_internet_gateway" "my_web_igw" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "${var.main_vpc_name} IGW"
  }
}

resource "aws_default_route_table" "main_vpc_default_rt" {
  default_route_table_id = aws_vpc.main.default_route_table_id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.my_web_igw.id
  }

  tags = {
    Name = "my-default-rt"
  }
}

resource "aws_default_security_group" "default_sec_group" {
  vpc_id = aws_vpc.main.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 8080
    to_port     = 8080
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 5000
    to_port     = 5000
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1" # any protocol
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    "Name" = "Default Security Group"
  }
}

# Create a new Key Pair
resource "aws_key_pair" "terraform_ssh_pair" {
  key_name = "terraform_rsa" 
  public_key = file(var.ssh_public_key)
}


data "aws_ami" "latest_amazon_linux2" {
  owners = [ "amazon" ]
  most_recent = true
  filter {
    name = "name"
    values = ["amzn2-ami-kernel-*-x86_64-gp2"] 
  }

  filter {
    name = "architecture"
    values = [ "x86_64" ]
  }

}

resource "aws_instance" "web-server" {
  ami                         = data.aws_ami.latest_amazon_linux2.id 
  instance_type               = "t2.micro"
  subnet_id                   = aws_subnet.web.id
  vpc_security_group_ids      = [aws_default_security_group.default_sec_group.id]
  associate_public_ip_address = true
  user_data = file("script.sh")
  key_name                    = aws_key_pair.terraform_ssh_pair.key_name
  tags = {
    "Name" : "My Public Web Server"
  }
}

The user_data is contained in script.sh below. This installs an apache server (to confirm if everything worked correctly). It also installs docker, terraform and runs an nginx docker container as well. You can modify the script to suit your requirements.

#!/bin/bash

# update vm and install server
sudo yum -y update && sudo yum -y install httpd
sudo systemctl start httpd && sudo systemctl enable httpd
sudo echo "<h1>Deployed via Terraform</h1>" > /var/www/html/index.html

# install terraform
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/AmazonLinux/hashicorp.repo
sudo yum -y install terraform
sudo touch ~/.bashrc
sudo terraform -install-autocomplete

# install docker
sudo yum -y install docker
sudo systemctl start docker
sudo amazon-linux-extras install docker
sudo service docker start
sudo usermod -aG docker ec2-user
sudo chkconfig docker on
sudo yum install -y git
sudo curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
sudo systemctl enable docker
sudo docker run -d -p 8080:80 nginx

3. Create a variables.tf file

touch variables.tf

Update variables.tf

variable "vpc_cidr_block" {
  type        = string
  description = "cidr block for the main vpc"
  default     = "10.0.0.0/16"
}

variable "web_subnet" {
  type        = string
  description = "cidr block for the web subnet"
  default     = "10.0.10.0/24"
}

variable "subnet_zone" {
  type        = string
  description = "availability zone for subnet zone"
  # subnet_zone was set as environment variable
}

variable "ssh_public_key" {
  type = string
  description = "public key that permits ssh connection to the ec2 instance"
}

variable "main_vpc_name" {
  type        = string
  description = "name of the main vpc"
}

variable "my_public_ip" {
  description = "my public ip address"
}

4. Create an output.tf file

touch output.tf

Update the output.tf file with the configuration below which provides the public IP address of the instance upon creation.

output "public_ip" {
  description = "The public IP address of the EC2 instance."
  value       = aws_instance.web-server.public_ip
}

5. Usage

Follow the previous steps to clone the repository, customize configurations, and run terraform apply.
After the Terraform apply, you will find the public IP address and the path to the local SSH private key in the outputs.
Use the following command to SSH into the EC2 instance:

ssh -i YourKeyName ec2-user@<public_ip>

Replace YourKeyName with the name of your private key file and with the actual public IP address.

Now, you can securely access your EC2 instance using the generated SSH key pair.

Automating Bulk WhatsApp Messaging for CRM: A Python Script

Caleb Yeboah — Tue, 26 Sep 2023 21:13:22 +0000

In today's fast-paced world, communication is key for businesses looking to engage with their clients and customers effectively. For many, WhatsApp has become a preferred channel due to its popularity and accessibility. However, sending individual messages to a large contact list can be time-consuming and inefficient. To address this challenge, we've developed a Python script that automates bulk WhatsApp messaging, making it easy to reach out to clients and customers seamlessly.

Introduction

WhatsApp is a powerful tool for connecting with clients and customers. However, sending messages to a long list of contacts manually can be a daunting task. Our Python script streamlines this process by allowing you to send bulk messages via WhatsApp. This script is designed to integrate seamlessly into a Customer Relationship Management (CRM) system, providing a more efficient way to communicate with your contacts.

Key Features

Our WhatsApp bulk messaging script comes with several key features:

1. Bulk Messaging: Send messages to multiple contacts at once, reducing the time and effort required for communication.

2. Customizable Messages: Personalize messages for each contact by using placeholders for contact information.

3. Contact List: Import a list of contacts from a CSV file, making it easy to manage your recipient list.

4. Automated Messaging: Schedule messages to be sent at specific times, allowing you to reach your contacts when it's most convenient.

5. Logging: Keep track of sent messages and any errors, ensuring transparency in your messaging process.

Prerequisites

Before you get started, you'll need a few things in place:

Python 3.6 or higher installed on your system.
The selenium library installed via pip.
The Chrome WebDriver compatible with your Chrome browser version.
A CSV file containing your contact list with at least two columns: Name and Phone.
Find starter code from my Github repo: https://github.com/CalebYeboah27/whatsapp_send_bulk

Getting Started

To begin automating your WhatsApp messaging, follow these steps:

1. Clone or Download the Repository

You can find the script in our GitHub repository. Clone or download it to your local machine.

2. Install Dependencies

Use pip to install the required selenium library.

pip install selenium

4. Run the Script

Execute the script using the following command:

python whatsapp_bulk_messaging.py

The script will guide you through the process of logging in to WhatsApp Web.

5. Send Bulk Messages

Follow the on-screen instructions, and the script will begin sending messages to your contacts based on your settings.

Usage Tips

Here are some tips to help you make the most of this script:

Keep your WhatsApp Web session open while the script is running.
Adjust the implicitly_wait to control the rate of message sending and avoid being flagged as spam.
Customize the contact.xlsx to include personalized information from your contact list.

License and Disclaimer

This project is open-source and licensed under the MIT License. Please use this script responsibly and ensure compliance with WhatsApp's terms of service and any applicable laws and regulations. The authors of this script are not responsible for any misuse or violation of WhatsApp's policies.

Conclusion

Efficient communication with clients and customers is essential for businesses of all sizes. Our WhatsApp bulk messaging script simplifies the process, allowing you to reach out to your contacts in a more organized and time-effective manner. By automating bulk messaging, you can focus on building stronger relationships with your clients and customers while saving valuable time and effort. Give it a try, and streamline your CRM communication today!