Forem: Victor Modebe

Create a Private Docker REPO on AWS ECR

Victor Modebe — Wed, 18 Jan 2023 09:15:56 +0000

Greetings, In this blog post I will demonstrate how to Create a private docker repository on amazon elastic container registry (ECR).

Creating a private Docker repository on Amazon Elastic Container Registry (ECR) allows you to securely store and manage your Docker images.
In this blog post, we will cover the steps to create a private Docker repository on Amazon ECR and how to push and pull images to and from the repository created.

Requirements for this tutorial

An AWS account: You will need to have an AWS account in order to access the ECR service.
IAM user with appropriate permissions: You will need to have an IAM user that has the necessary permissions to create and manage ECR repositories and images. This will typically include permissions such as ecr:CreateRepository, ecr:ListImages, ecr:DescribeRepositories, ecr:PutImage, and ecr:GetAuthorizationToken.
Docker installed on your machine: You will need to have Docker installed on your machine in order to interact with the ECR repository using the Docker command-line interface.
AWS CLI installed on your machine: You will need to have AWS CLI installed on your machine to perform the authentication step.
It is also good to have some knowledge of the basics of Docker and AWS, as well as experience working with the command-line interface to be able to follow through with this tutorial.

That being said lets deep dive into the tutorial which is described in several steps.

Step 1: Create an Amazon ECR Repository

Log in to the AWS Management Console and navigate to ECR.
Click on the "Create repository" button.
Give your repository a name and click on the "Create repository" button.
Step 2: Authenticate Docker to Your AWS Account

Run the following command in your terminal to authenticate Docker to your AWS account:

aws ecr get-login-password --region <your-region> | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.<your-region>.amazonaws.com

Step 3: Tag Your Docker Image

Run the following command to tag your Docker image with the repository name and the tag you want to use. Replace the placeholders with your own values:

docker tag <image-name> <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/<repository-name>:<tag>

Step 4: Push the Image to the Repository

Run the following command to push the image to the repository:

docker push <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/<repository-name>:<tag>

Step 5: Pulling Images from the Repository

Run the following command to pull an image from the repository:

docker pull <your-account-id>.dkr.ecr.<your-region>.amazonaws.com/<repository-name>:<tag>

Once you've followed these steps, your private Docker repository on Amazon ECR is set up and ready to use. You can push and pull images to and from the repository as needed. Keep in mind that only users with the appropriate permissions will be able to access and manage the images in your private repository.

In addition, you can use AWS CLI or SDKs to automate the process of creating and managing repositories, images, and permissions.

In this way, you can easily create a private Docker repository on Amazon ECR and manage your Docker images with more security and flexibility.

Thanks for reading hope this helps someone...

SEND TEXT MESSAGES USING AMAZON SNS WITH PYTHON (Boto3)

Victor Modebe — Mon, 19 Dec 2022 17:42:37 +0000

Greetings guys!!! I will show you how to send SMS messages to a phone number using Amazon Simple Notification Service (SNS) and Python.

Before we start I will introduce you to the services we will use for this tutorial.

Introduction

Amazon Simple Notification Service (SNS) is a fully managed messaging service that enables you to send messages to all devices (such as iOS, Android, and Fire OS devices) and email clients. It is a flexible, cost-effective way to send SMS messages, and it can be integrated with other AWS services such as Amazon Lambda and Amazon CloudWatch.

In this tutorial, I will show you how to send SMS messages to a phone number using Python and the AWS SDK for Python (Boto3).

Boto3 is the Amazon Web Services (AWS) Software Development Kit (SDK) for Python, which allows Python developers to write software that makes use of services like Amazon S3 and Amazon EC2.

Boto3 provides a convenient and easy-to-use API for interacting with AWS services such as Amazon SNS, Amazon S3, and Amazon EC2. It is built on top of the AWS HTTP API and provides a Pythonic interface to AWS services. With Boto3, you can write Python scripts to manage and automate AWS resources, as well as customize the behavior of AWS services.

Prerequisites

Before you begin, make sure you have the following:

An AWS account. If you don't have one, you can create one for free at aws.amazon.com.
Python 3.10.9 or latest version. You can check your Python version by running the following command: python -V
The AWS CLI (Command Line Interface) installed and configured on your machine.

Setting up Amazon CLI

The AWS Command Line Interface (CLI) is a unified tool used to manage your AWS services. With the AWS CLI, you can control multiple AWS services from the command line, and automate them through scripts.

To set up the AWS CLI on your machine, follow these steps:

Install Python 3.10.9 or latest version. You can check your Python version by running the following command:



$ python3 --version

Install pip, the Python package manager. You can install pip by running the following command:



$ python3 -m ensurepip

Install the AWS CLI. You can install the AWS CLI by running the following command:



$ pip3 install awscli

Configure the AWS CLI. You can configure the AWS CLI by running the aws configure command and following the prompts. You will need to provide your AWS access key and secret key, as well as the default region and output format. You can obtain your access key and secret key by signing in to the AWS Management Console and navigating to the IAM (Identity and Access Management) dashboard.

After you have installed and configured the AWS CLI, you can use it to manage your AWS resources from the command line. For example, to list all the S3 buckets in your account, you can use the command:



$ aws s3 ls

Setting up Amazon SNS

To send an SMS message using Amazon SNS, you need to set up in several ways.
Find below two steps to setup Amazon SNS.

Step 1

login to your aws account,
then type in sns on the search bar.
Click menu bar on the left
Scroll down to Mobile then click 'Text messaging (SMS)'
Scroll down and click add phone number.
Add your phone number and select a language the verification message will be sent in, then add phone number.
Input the verification code and then click verify phone number If done correctly you should see your number as verified below

Step 2

Sign in to the AWS Management Console and navigate to the Amazon SNS dashboard.
Click the Create topic button.
Enter a Topic name and a Display name for your topic, and then click the Create topic button.
In the Subscriptions tab, click the Create subscription button.
Select SMS as the Protocol and enter the phone number that you want to subscribe to the topic.
Click the Create subscription button to subscribe the phone number to the topic.

Sending SMS messages with Python

Now that you have set up an SNS topic and subscribed a phone number to the topic, you can use Python and the Boto3 library to send SMS messages to the phone number.

First, install the Boto3 library by running the following command:



$ pip3 install boto3

Next, create a Python script and import the boto3 library. Then, create an SNS client using the following code:



import boto3

# Create an SNS client
sns_client = boto3.client('sns')

create three variables one for phone number and the other for message. Add the contents of your message and the actual phone number that will receive the message in the defined variables.



phone_number = '+1234567890'
message = "This is a test message sent from Nnamdi using Amazon SNS and python."
# Set the topic ARN that the phone number is subscribed to
topic_arn = 'arn:aws:sns:us-east-1:123456789012:MyTopic'

To send an SMS message, you can use the publish() method of the client object. The publish() method requires the following parameters:

PhoneNumber: The phone number to which you want to send the SMS message.
Message: The content of the SMS message.
TopicArn: A unique identifier for a topic in the Amazon Simple Notification Service (SNS). A topic is a logical access point and communication channel for allowing messages to be published to subscribing endpoints or clients.

Here is an example of how to send an SMS message using the publish() method:



# Send the SMS message
response = sns.publish(
    PhoneNumber=phone_number,
    Message=message,
    TopicArn=topic_arn
)

Next and final step print out the code which will notify you a response if the message fails or sends successfully. It will also display the message ID



print(f"Message sent! Message ID: {response['MessageId']}")

This will send the SMS message to the phone number that is subscribed to the specified SNS topic.

Note that the phone number that you are sending the SMS message to must be subscribed to the SNS topic that you are specifying in the TopicArn parameter.

Alternatively you can choose to send to the verified number I showed you earlier and take out the SNS TopicArn line of code like below



phone_number = '+1234567890'  # add recipients phone number here
message = "Test Message from nnamdi"  # add message here

# Send the message
response = sns_client.publish(
    PhoneNumber=phone_number,
    Message=message
)

You should get the prompt below if you followed the process correctly.

NB: The number we verified is in the SMS Sandbox in US East(North Virginia) region. When in the sandbox, you can only deliver SMS to the sandbox destination phone numbers you have verified.
When your account is moved out of the sandbox, these restrictions are removed, and you can send SMS messages to any recipient.
To move your account out of the sandbox click the link to get detailed steps from AWS AMAZON SNS SMS SANDBOX DOCUMENT

I hope this helps!!!

You can get the python script from my GitHub repo

Launching a VPC with Public subnet and Private subnet in AWS using Terraform

Victor Modebe — Sat, 17 Dec 2022 10:00:43 +0000

In this blog post I will launch a VPC and configure it with 2 subnets, one public and one private. A WORDPRESS EC2 instance will be created in the public subnet while a MYSQL instance will be created in the private subnet. I will create a Bastion host or jump box which will allow SSH connections to the MYSQL instance which is created in the private subnet. It is best practice when creating a multi-tier website with web server in public subnets and database server in private subnet so no one can have access to it since its private.

For this tutorial the wordpress will be a public facing application while the MYSQL will be the backend database server.
I will use visual studio code.

Long long ago, writing codes for all the infrastructure for testing, debugging and deploying would have consumed a good amount of valuable time. It is really difficult to tell which infrastructure as code tool was first created and released but in the early- to mid- 2000's Chef, Puppet and Ansible were first released. These tools allowed users to define and manage their infrastructure using configuration files, which enabled them to automate the provisioning and management of their infrastructure in a repeatable and predictable way. AWESOME!!! discovery right??? I read your mind LOL!!!

Over time, the concept of infrastructure as code has continued to evolve, and more specialized tools like Terraform, CloudFormation, and ARM Templates have been developed to help users manage their infrastructure more effectively. These tools provide a higher-level abstraction for defining infrastructure, and they often integrate with other tools and services to provide a more comprehensive infrastructure as code solution.

For this blog post we will use Terraform because it has several advantages over other IaC tool the major reason being that it is cloud agnostic which means it can be used to manage infrastructure on various cloud and on-premises platforms.
This makes it easy for organizations to use a single tool to manage their infrastructure across different environments, and avoid vendor lock-in.
you can read more about terraform here

In this blog post I will guide you to construct the pipeline described in the first paragraph of this blog.

Life these days is all about automation, which makes living much more easy. Productivity has increased by a large margin, tech companies delivery services much more faster as compared to the early years of software development. It will only get better and faster with Artificial Intelligence and Machine learning. What a future we have ahead of us.

Prerequisites to implement this pipeline

1. Some knowledge of AWS & Github.
2. You need to have some knowledge of JSON, arghh!!! me too, not to worry, I will simplify as much as possible. In this Pipeline, terraform is written in HCL (HashiCorp Configuration Language) & it is quite similar to JSON. Hence you will need basic knowledge of terraform
3. Basic knowledge of Docker is required
4. You will need to install AWS CLI & terraform

We are definitely making progress :) now I will list the steps required to automate the process described above using terraform. Watch and learn how will terraform bring to life the infrastructure we have described above with codes.

Steps to provision the infrastructure
1. Create a var.tf, provider.tf, main.tf, vpc.tf and output.tf files. this is where we will write our codes.
2. Create a provider inside provider.tf file.
3. Create an AWS key pair inside main.tf file.
4. Create a VPC (Virtual Private Cloud in AWS) inside vpc.tf file.
5. Create public and private subnet with map public ip on launch set to true inside vpc.tf file.
6. Create an Internet Gateway for Instances in the public subnet to access the Internet.
7. Create a route table that allows traffic to be routed through the Internet Gateway.
8. Create an association the route which will associate the route table to the public internet.
9. Create a Security Group and EC2 Instance for the Bastion Host.
10. Create a Security Group and EC2 Instance for the Wordpress .
11. Create a Security Group and EC2 Instance for the MYSQL Database.
12. Validate, plan & apply our Terraform configuration code.
13. Connect to the instances created and test SSH connection.
14. Create an outputs.tf file and input some code to display the resource id.
15. Launch a Bastion Host.
16. Final step configure Wordpress and upload some images.

Step 1
I will create a var.tf file where I will store all my variables. You can add any variable you want just remember to call the variable when you need it. which I will show in later steps.

#create variable, specify type and set to default
#create variable, specify type and set to default
variable "awsprops" {
  type = map(any)
  default = {
    region       = "us-east-1"
    ami          = "ami-0b0dcb5067f052a63"
    instancetype = "t2.micro"
    az1          = "us-east-1a"
    az2          = "us-east-1b"
  }
}

# key variable for refrencing 
variable "keyname" {
  default = "NV_R_key"
}

# base_path for refrencing 
variable "base_path" {
  default = "/Users/mac/Desktop/terraform-projects/"
}

Step 2
I will create a provider. Notice how I called up region by using 'var.awsprops' which I defined in the variable file.

#create provider and specify provider name
provider "aws" {
  region = lookup(var.awsprops, "region")
}

Step 3
I will create an AWS Key pair.
To authenticate with the remote host, you would need to have a copy of the corresponding public key, which you would typically add to your ~/.ssh/authorized_keys file on the client machine.

#this will create key with RSA algorithm and 4096 rsa bits
resource "tls_private_key" "private_key" {
  algorithm = "RSA"
  rsa_bits  = 4096
}
#this will create a key pair using the private key defined above  
resource "aws_key_pair" "Key-Pair" {
  key_name   = lookup(var.awsprops, "keyname")  # key name
  public_key = pls_private_key.private_key.public_key_openssh

 }

# this terraform resource will save private key at specified path.
resource "local_file" "storekey" {
  content = tls_private_key.private_key.private_key_pem
  filename = "${var.base_path}${var.key_name}.pem"
}

Step 4
In this step we will be creating the backbone of this infrastructure called Virtual Private Cloud (VPC). We will use 10.0.0.0/16 CIDR block and enable DNS hostname, which is used to enable automatic of assignment of public DNS hostname to EC2 Instances.

#create a VPC and define the ip range
resource "aws_vpc" "prod_vpc" {
  cidr_block           = "10.0.0.0/16" #ip range for the vpc
  enable_dns_hostnames = true 

  tags = {
    Name = "Production_VPC"
  }
}

Step 5
In this step we will create subnets. One will be public and the other private. Here map_public_ip_on_launch is set to true which will automatically assign a public ip to the instance when launched.
In Terraform, the depends_on meta-argument can be used to specify that one resource depends on another resource. This means that the specified resource(s) will be created before the resource that specifies the depends_on argument.

#create public subnet
resource "aws_subnet" "prod_public_subnet" {
  depends_on = [aws_vpc.prod_vpc]

  vpc_id                  = aws_vpc.prod_vpc.id
  availability_zone       = lookup(var.awsprops, "az1")
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true #connect public subnet to the internet

  tags = {
    Name = "Public_Subnet_PROD"
  }
}

#create private subnet
resource "aws_subnet" "prod_private_subnet" {
  depends_on = [aws_vpc.prod_vpc] 

  vpc_id            = aws_vpc.prod_vpc.id
  availability_zone = lookup(var.awsprops, "az2")
  cidr_block        = "10.0.2.0/24"

  tags = {
    Name = "Private_Subnet_PROD"
  }
}

Step 6
In this step we will create the internet gateway. The internet gateway is a VPC component that enables instances in the VPC to connect to the public internet

#create an internet gateway for the vpc
resource "aws_internet_gateway" "prod_igw" {
  depends_on = [aws_vpc.prod_vpc]
  vpc_id = aws_vpc.prod_vpc.id
  tags = {
    Name = "prod-igw"
  }
}

Step 7
Here we will create a route table. This will create a route in the VPC's main route table that allows traffic with a destination of 0.0.0.0/0 (i.e., all destinations) to be routed through the Internet Gateway. This will allow instances in the VPC to access the internet.

#create a route table which targets the internet gateway
resource "aws_route_table" "prod_igw_rt" {
  depends_on = [aws_vpc.prod_vpc,
  aws_internet_gateway.prod_igw]

  vpc_id = aws_vpc.prod_vpc.id

  #set default ipv4 route to use the internet gateway
  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.prod_igw.id
  }
  tags = {
    Name = "Prod-Route-Table"
  }
}

Step 8
In this step we will create route table associations which will associate the route table to the public subnet

#here we create the route table association to the Public subnet
resource "aws_route_table_association" "associate_prod_rt_public_subnet" {
  depends_on = [aws_subnet.prod_public_subnet,
    aws_route_table.prod_igw_rt]

  subnet_id      = aws_subnet.prod_public_subnet.id
  route_table_id = aws_route_table.prod_igw_rt.id
}

Step 9
In this step we will create a security group for the bastion host and launch an EC2 instance for the Bastian host as well. A bastion host is a special server on a network specifically designed and configured to withstand attacks. It is typically used to control access to a private network from an external network, such as the internet.

We will launch a bastion host in the public subnet and from there we SSH into our instances located in the private subnet.

resource "aws_security_group" "bastion-sg" {
  depends_on = [aws_vpc.prod_vpc] #this means the vpc resource will be created before the bastion host sg

  name        = "Bastion_Host_SG"
  description = "Security Group for Bastion Host"
  vpc_id      = aws_vpc.prod_vpc.id

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

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

# created bastion host ec2 instance
resource "aws_instance" "bastion_host" {
  ami                    = lookup(var.awsprops, "ami")
  instance_type          = lookup(var.awsprops, "instancetype")
  key_name               = var.keyname
  vpc_security_group_ids = [aws_security_group.bastion-sg.id]
  subnet_id              = aws_subnet.prod_public_subnet.id

  tags = {
    Name = "Bastion_host"
  }

  connection {
    user        = "ec2-user"
    private_key = file("/Users/mac/Desktop/terraform-projects/NV_R_key.pem")
    host        = aws_instance.bastion_host.public_ip

  }
}

Step 10
Now we create a security group for our wordpress instance and also create resources for the wordpress instance.
In our security group we will allow port 80 for HTTP traffic from anywhere and for SSH we will allow port 22 from the bastion host security group. On the CIDR block we can input the bastion host's Ip but it will be bad practice because several conditions can cause it to change or we can use an elastic Ip (EIP) which will make it static. But for this tutorial we will add the bastion host's security group.

The 'user_data' argument can be used to specify data that should be passed to the instance when launched. We will install docker, pull Wordpress image from the docker hub while we launch a wordpress container with this image in the user_data script. Environment variables will be passed while launching wordpress so it automatically configures the MYSQL database.

resource "aws_security_group" "wordpress-sg" {
  depends_on = [aws_vpc.prod_vpc]

  name        = "Wordpress_SG"
  description = "Security Group for Wordpress EC2 Instance"
  vpc_id      = aws_vpc.prod_vpc.id

  #created an inbound rule for HTTP
  ingress {
    description = "Allow TCP"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]

  }

  #created an inbound rule for PING
  ingress {
    description = "Allow PING"
    from_port   = 0
    to_port     = 0
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]

  }

  #created an inbound rule for SSH
  ingress {
    description     = "Allow SSH"
    from_port       = 22
    to_port         = 22
    protocol        = "tcp"
    cidr_blocks     = ["0.0.0.0/0"]
    security_groups = [aws_security_group.bastion-sg.id]

  }

  #created an outbound rule for the wordpress
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = -1
    cidr_blocks = ["0.0.0.0/0"]
  }
  tags = {
    Name = "Wordpress-SG"
  }

}

#created wordpress EC2 Instance
resource "aws_instance" "wordpress" {
  ami                    = lookup(var.awsprops, "ami")
  instance_type          = lookup(var.awsprops, "instancetype")
  vpc_security_group_ids = [aws_security_group.wordpress-sg.id]
  subnet_id              = aws_subnet.prod_public_subnet.id
  key_name               = var.keyname
  user_data              = <<EOF
            #! /bin/bash
            yum update
            yum install docker -y
            systemctl restart docker
            systemctl enable docker
            docker pull wordpress
            docker run --name wordpress -p 80:80 -e WORDPRESS_DB_HOST=${aws_instance.mysql.private_ip} \
            -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=root -e WORDPRESS_DB_NAME=wordpressdb -d wordpress
  EOF

  tags = {
    Name = "Wordpress_Instance"
  }
}

Step 11
Now we will launch an EC2 instance for the MYSQL in the private subnet.
MySQL uses port 3306 as the default port for incoming connections. When defining egress we use protocol '-1' which is a placeholder or wildcard value or the specific protocol can be anything or not relevant/important. We are attaching the wordpress security group to mysql inbound traffic to only allow access it. We also added the bastion host security group which will only allow SSH access to the MSQL Instance.

resource "aws_security_group" "mysql-sg" {
  depends_on = [
    aws_vpc.prod_vpc,
  ]

  name        = "MYSQL_SG"
  description = "Security Group for MYSQL EC2 Instance"
  vpc_id      = aws_vpc.prod_vpc.id

  ingress {
    description     = "allow TCP"
    from_port       = 3306
    to_port         = 3306
    protocol        = "tcp"
    cidr_blocks     = ["0.0.0.0/0"]
    security_groups = [aws_security_group.wordpress-sg.id]
  }

  ingress {
    description     = "allow SSH"
    from_port       = 22
    to_port         = 22
    protocol        = "tcp"
    cidr_blocks     = ["0.0.0.0/0"]
    security_groups = [aws_security_group.bastion-sg.id]
  }

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

# created a mysql ec2 instance
resource "aws_instance" "mysql" {
  ami                    = lookup(var.awsprops, "ami")
  instance_type          = lookup(var.awsprops, "instancetype")
  key_name               = var.keyname
  vpc_security_group_ids = [aws_security_group.mysql-sg.id]
  subnet_id              = aws_subnet.prod_public_subnet.id
  user_data              = file("mysqlconfig.sh")

  tags = {
    Name = "MSQL-Instance"
  }
}

From above We will pass a script in 'user_data' but this time we save the file locally and call it up with the file command. The file is a bash file hence it will be saved with suffix '.sh' ("mysqlconfig.sh") with configurations below. Make sure to input the latest version of mysql to avoid compatibility issues. The latest version when writing this blog is 8.0.31.

#! /bin/bash
yum update
yum install docker -y
systemctl restart docker
systemctl enable docker
docker pull mysql
docker run --name mysql -e MYSQL_ROOT_PASSWORD=root \
-e MYSQL_DATABASE=wordpressdb -p 3306:3306 -d mysql:8.0.31

Step 12
We have written code for our infrastructure using terraform, which took some time and was a bit technical. Now we will use some terraform commands to check if our code is valid, create an execution plan and finally apply changes based on the desired state defined in our configuration files.

#validate syntax and overall structure our our terraform configuration
terraform validate

#generate execution plan and view changes made to our configurations
terraform plan

#apply changes to infrastructure 
terraform apply

If you are on the right track you should get the prompt below after the infrastructure has deployed on AWS

[ ]

Step 13
connect to the wordpress EC2 instance via ssh or via EC2 Instance connect from the AWS management console. Once you are connected follow the prompt to configure wordpress. You can also copy the IP address of the wordpress paste on your browser then configure Wordpress.

Step 14
You can optionally create an outputs.tf file. In Terraform, you can use output variables to display the values of resources created by a configuration.

output "us-east-1a-Public-IP" {
  value       = aws_instance.wordpress.public_ip
  description = "The Public IP address of the Web Server"
}

output "us-east-1b-Public-IP" {
  value       = aws_instance.bastion_host.public_ip
  description = "The Public IP address of Bastion Host"
}

output "us-east-1a-Private-IP" {
  value       = aws_instance.mysql.private_ip
  description = "The Private IP address of MySQL Database"
}

output "vpc_id" {
  value       = aws_vpc.prod_vpc.id
  description = "The Virtual Private Cloud(VPC) ID "
}

You can then use the terraform output command to display the values of these output variables after running the terraform apply command.

$ terraform output prod_vpc_id
vpc-06578e6056e120939

$ terraform output us-east-1a-Public-IP
54.164.193.1

FINAL STEP
This is the final view once wordpress has been configured, you can upload random images or type some text to your blog.

We have succeeded in creating a VPC with 1 Public & 1 Private Subnet using Terraform. We also deployed wordpress and mysql using docker while passing user data to the instance. Remember to type 'terraform destroy' to destroy all the infrastructure deployed to avoid incurring unnecessary charges.

I hope you learnt a lot from this article good luck on your cloud journey :)

You can get the full code from my GitHub repo below

ROCK PAPER SCISSORS PYTHON GAME

Victor Modebe — Thu, 15 Dec 2022 11:37:10 +0000

Greetings guys!!!
This tutorial is for people who are new to python and are looking to learn more about it. I would recommend taking the "learn by doing" method, as practical experimentation solidifies your understanding of a topic.

I will use Visual Studio Code as my IDE, you can use any IDE of your choice. Download a copy of VSCode for your operating system from https://code.visualstudio.com/download

To install Python on your computer, you will need to go to the Python website (https://www.python.org/), download the appropriate installer for your operating system, and run the installer.

Here are the specific steps for Mac, windows, Linux operating systems:

macOS:
1.Go to the Python website: https://www.python.org/downloads/macos/
2.Select the appropriate installer for your operating system architecture.
3.When the download is complete, open the downloaded file (called "python-3.11.1.pkg") and follow the prompts to install Python on your computer.

Windows:
1.Go to the Python website: https://www.python.org/downloads/windows/
2.Select the appropriate installer for your operating system architecture.
3.When the download is complete, open the downloaded file (called "python-3.11.1.exe") and follow the prompts to install Python on your computer.

Linux:
1.Open a terminal window.
2.Use the following command to install Python 3 and pip (the package manager for Python). Make sure to use the latest version of python to install pip. When writing this blog the latest version of python is 3:

sudo apt-get install python3 python3-pip

This will install the latest version of Python 3 and pip. To verify that the installation was successful, you can run the following commands to check the version of Python and pip that are installed:

python3 --version
pip3 --version

These commands should print the version numbers of Python and pip, respectively. If you see version numbers printed, then Python and pip are installed and ready to use.

Now we are done with the installation of Vscode & Python successfully, the next step is to open Vscode create a folder the create a file with .py extension .py as show below.

Now we dive in to write our code.
Below is a 4 step explanation of the code required for 'ROCK PAPPER SCISSORS' game written in python:

STEP 1
To begin with, we will start by importing the random module. We will also define a custom function 'def get_computer_choice' that takes in the player's choice (either "rock", "paper", or "scissors")and returns the computer's choice, randomly selected from the same three options:

import random

def get_computer_choice(player_choice):
    choices = ["rock", "paper", "scissors"]

    return random.choice(choices)

STEP 2
In this step we define a custom function 'def get_game_result' that takes in the player's choice and the computer's choice, and returns a string representing the outcome of the game. The possible return values are "player wins", "computer wins", and "tie".

def get_game_result(player_choice, computer_choice):
    if player_choice == "rock" and computer_choice == "scissors":
        return "player wins"
    elif player_choice == "rock" and computer_choice == "paper":
        return "computer wins"
    elif player_choice == "paper" and computer_choice == "rock":
        return "player wins"
    elif player_choice == "paper" and computer_choice == "scissors":
        return "computer wins"
    elif player_choice == "scissors" and computer_choice == "rock":
        return "computer wins"
    elif player_choice == "scissors" and computer_choice == "paper":
        return "player wins"
    else:
        return "tie"

STEP 3
In this step we use a while loop which is the main game loop. It continues to run until the player decides to quit by typing 'quit', executed with 'break' an inbuilt- keyword in python .

while True:
    player_choice = input(
        "Please enter your choice (rock, paper, scissors, or quit): ")
    if player_choice.lower() == "quit":
        break

STEP 4
Finally, we define the outcome of the computers choice and print out the game results.

computer_choice = get_computer_choice(player_choice)
    result = get_game_result(player_choice, computer_choice)
    print(f"You chose {player_choice}, the computer chose {computer_choice}.")
    print(f"Result: {result}.")

Congratulations!!! You now have written a python code for 'ROCK PAPER SCISSOR' game. You can play against the computer as many times as you want, and see who comes out on top. Quit the game by typing quit.

If you followed my instructions correctly. This should be how your code will look in VSCode. Also remember, to run your code click the run button on the far right side of the app.

The results should appear like below

You can learn more about python from Mosh Hamedani's on python tutorial from his YouTube channel
https://www.youtube.com/watch?v=_uQrJ0TkZlc

Good luck in your Python journey!!!