DEV Community: Salman Sohail

Creating a Ruby gem using Thor generator

Salman Sohail — Wed, 02 Mar 2022 03:33:15 +0000

I have been writing ruby gems for sometime now and always wish that there could be a command that can generate the gem structure/boilerplate and the things I love pre-configured for me.

This is where Thor comes in handy. I am going to introduce you to Thor a.k.a the badass command line generator that will make your life easy when it comes to ruby gem creation.

I do want to mention Mariella Miranda who’s article on this topic inspired me to create a project which can be used as a gem generator to save you a lot of time.

just imagine this command:

thor mygem age_calculator

Produces this:

age_calculator
│ README.md
│ age_calculator.gemspec
│ Gemfile
│ .gitignore
│
└───lib
│ │ age_calculator.rb
│ └───age_calculator
        │ version.rb
│   
└───spec
    └───age_calculator
    │ age_calculator_spec.rb
    │ spec_helper.rb

Let’s do this!

Install thor

gem install thor

Clone my repository from github

git clone https://github.com/saluminati/gem_generator.git

Link to my repo https://github.com/saluminati/gem_generator

Getting started

cd gem_generator
thor gem_generator age_calculator

Your gem with all the required files is now created in the age_calculator directory

You can also append gem generator with use_rspec_suit and use_rubocop options have rspec and rubocop pre-installed and configured with your

Example:

thor gem_generator age_calculator --use_rspec_suit=true --use_rubocop=true

Once your gem is created, make sure that you try to build it.

Example:

cd age_calculator
bundle install
gem build age_calculator.gemspec

Some explanation – As I promised

Content of gem_generator.thor file

Our main file is gem_generator.thor which holds everything together.

This file is extended from Thor::Group which, in a nutshell will execute all the methods defined in this class in the order they were defined.

If you look at the methods inside this class, it is creating the gem directory and copying the templates files within your gem namespace with everything per-configured.

Happy coding! please let me know if you run into any issue.

Putting all things together using AWS Task Definition

Salman Sohail — Fri, 27 Dec 2019 13:56:51 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

In the previous article, We have created the ECS Task Definition which has our Docker Image container along with environment variables and we also have mounted EFS volumes for plugins and cache.

In this article, our website will go live with Load Balancer and Autoscalling groups (having multiple WordPress instances on demand). This means that AWS can increase the number of WordPress instances on demand and it can scale it down too.

We will do the following in this article:

Create ECS Cluster
Create Service for WordPress Task Definition
Configure Autoscalling

Create ECS Cluster

Go to ECS from your AWS console service tab and select Clusters, Click on Create Cluster

Step 1: Select Cluster template

Select EC2 Linux + Networking

Step 2: Configure cluster

I have used m5a.large instance size. You can choose whatever instance size is suitable for you.

Please select the instance Security Group we created earlier. This cluster will create an EC2 instance for us. We will place our WordPress Docker image on this instance.

Hit Create button and it will create the Cluster for you.

You should be able to see your cluster in the list.

Add Service to your Cluster

Click on the cluster your have created and click on Create

Adding Load Balancer

Select your wordpress Load Balancer created earlier.

Click on Add to load balancer button

Select the target group created for the Load Balancer.

Un-select the Enable service discovery integration

Configure Autoscaling Group

You can change these variables as per your requirements. In our case, it will create two EC2 instances for us and place our WordPress website on each of them.

Creating Scale UP and Scale Down policies.

Something has to trigger an alarm so AWS EC2 can add or reduce number of instances for us. I am using CPU Utilization in our example. There are many more options.

To keep it simple, we are saying that if the CPU Utilization is above 60% for 5 minutes, add another instance. If the CPU Utilization is below 50% for 5 minutes, reduce instances to just 1.

Service and Task Tabs

Now if you go back to your Cluster, You should be able to see that the new service and task has been added.

Sucess !!!!

if everything goes well which I hope it will, Copy and past your Load Balancer DNS URL in the browser and you should see your WordPress website setup screen.

If, for some reason, things don’t go well and you don’t see this page. Please check how to Trouble shoot the problem below.

Troubleshooting

If something has gone wrong, your task will fail again and again. in order to find out what is wrong, click on the task and it will take you to a screen like this:

If something went wrong inside your container, you can investigate it inside the Logs tab.

Otherwise expand the web container under the Details tab of the task and you will see Exit code and reason why the task has failed.

Create Task Definition for WordPress Docker Project

Salman Sohail — Fri, 27 Dec 2019 12:44:21 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

In this article, we will create an ECS task definition containing our WordPress Docker image reference from ECR, Environment variables such as Database credentials, EFS volume mount for our plugins storage (Don’t worry I will shed more light on this later) and some WordPress website constants such as WP_SITE_URL etc.

If you have used Docker Compose before, ECS Task Definition concept is quite similar to that.

Fasten your seat belts, there will be some steps involved to get the ECS Task Definition setup.

Before we began

In the task definition, we will pass some environment variables such as Database host, Database name, user, password, some WordPress constants such as website URL etc.

The first thing we need is the WEBSITE_URL. In the beginning, we can use the DNS name of our Load Balancer.

Go to your EC2 console and select Load Balancer. You will be able to see the DNS name of your Load Balancer here. Please take a note of this URL.

We can change this URL once our domain is linked to the Load Balancer. This can be easily done by using AWS route 53 later.

We also need our Database credentials. Go to RDS from service tab and select Database. Click on the database you have created. Under Connectivity & security section, you will find the URL there. We will be using this URL soon.

Create Task Definition

Go to ECS from your AWS Service tab and select Task Definitions, now click on Create New Task Definition

Step 1: Select launch type compatibility

We will choose EC2 on the next step

Step 2: Configure task and container definitions

We will add a container which have our Docker Project along with some configurations.

You can give any name to your container, in our case we have used web. In the image field, paste your ECR repository’s latest version link. Please refer to Build and Push wordpress project to AWS ECR Push to AWS ECR ! section.

The reason to add 0 -> 80 in the port mappings is to map any port from outside world (Load Balancer in our case) to container’s port 80.

Environment

This is the most important part of our container, we will pass the Database credentials to our Docker Image file along with some other configurations.

We will set the following environment variables:

WORDPRESS_DB_HOST (RDS end point URL)
- Go to RDS from service tab and select Database. Click on the database you have created. Under Connectivity & security section, you will find the URL.
WORDPRESS_DB_NAME
WORDPRESS_DB_USER
WORDPRESS_DB_PASSWORD
- The database name, user and password you have already set while creating the RDS DB

WORDPRESS_CONFIG_EXTRA

define( 'WP_HOME', 'http://wwordpress-elb-1695594798.ap-southeast-2.elb.amazonaws.com
' ); define( 'WP_SITEURL', 'http://wwordpress-elb-1695594798.ap-southeast-2.elb.amazonaws.com
' ); define('CONCATENATE_SCRIPTS', false); define('WPINV_USE_PHP_SESSIONS', false);define('FS_METHOD', 'direct');

Replace wwordpress-elb-1695594798.ap-southeast-2.elb.amazonaws.com with your Load DNS URL

If your wordpress website requires setting up any constant, WORDPRESS_CONFIG_EXTRA is where you can append it.

AWS Logs

Scroll down to the STORAGE AND LOGGING section and enable AWS logs. This will help to troubleshoot if there’s any issue with your website.

Click on Add and we’re almost done.

Volumes for Cache and Plugins

Now its time to use a centralized storage for plugins. This is one of the biggest challenges I have faced when it comes to develop a high traffic multi instance WordPress website which can scale up and scale down on demand.

Now its time to use our EFS file system we have created for Plugins storage and cache.

We will have to create two volumes i.e. efs-plugins and efs-cache within our container. for that, Scroll down and click on Configure Via JSON button

find “volumes”: [] and add update this JSON array

 "volumes": [
        {
            "name": "efs-plugins",
            "host": null,
            "dockerVolumeConfiguration": {
                "autoprovision": null,
                "labels": null,
                "scope": "task",
                "driver": "local",
                "driverOpts": {
                    "type": "nfs",
                    "device": ":/",
                    "o": "addr=fs-565d626f.efs.ap-southeast-2.amazonaws.com,nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport"
                }
            }
        },
        {
            "name": "efs-cache",
            "host": null,
            "dockerVolumeConfiguration": {
                "autoprovision": null,
                "labels": null,
                "scope": "task",
                "driver": "local",
                "driverOpts": {
                    "type": "nfs",
                    "device": ":/cache",
                    "o": "addr=fs-565d626f.efs.ap-southeast-2.amazonaws.com,nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport"
                }
            }
        }
    ],

Replace fs-565d626f.efs.ap-southeast-2.amazonaws.com with your EFS volume URL.

Volumes have been added now we need to mount these volumes. find “mountPoints”: [] in the JSON and update it with the following.

 "mountPoints": [
                {
                    "readOnly": false,
                    "containerPath": "/var/www/html/wp-content/plugins",
                    "sourceVolume": "efs-plugins"
                },
                {
                    "readOnly": false,
                    "containerPath": "/var/www/html/wp-content/cache",
                    "sourceVolume": "efs-cache"
                }
            ],

Hit Save and then click on create. Our task definition is now created and ready to rock and roll very soon !!

Create Load Balancer for WordPress website

Putting all things together using AWS Task Definition

Create Load Balancer for WordPress website

Salman Sohail — Fri, 27 Dec 2019 11:32:31 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

In this article, we will create the Load Balancer which will sit on top on WordPress instances and balance the load as per increasing the requests from users. The ultimate reason for this approach is to make your website scalable and always available for our clients.

From EC2 console Select Load Balancer and click on Create Load Balancer

On this step, select HTTP/HTTPS

Step: Configure Load Balancer and VPC

Make sure you select the correct VPC on this step.

Step: Configure Security Groups

On this step, we will use the Security Group we created earlier for our Load Balancer.

Step: Configure Routing (Target Group)

Target Group job is to ping your instances periodically to make sure that they are healthy. If it does not receive the response from any of the instance, it raises the alarm and the instance is marked as unhealthly by the Load Balancer and an action can be taken accordingly.

by doing all these steps, we have successfully created the mechanism for a scalable WordPress website that can serve as thousands of clients with any amazing user experience.

Build and Push wordpress project to AWS ECR

Create Task Definition for WordPress Docker Project

Create AWS EFS (Elastic File System) Plugin storage for WordPress behind Load Balancer

Salman Sohail — Fri, 27 Dec 2019 01:54:17 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

Why do we need to use EFS for plugin storage

We all love the fact that on WordPress, we can install plugins without a deployment. Here’s the challenge with this approach, if your WordPress website is behind a Load balancer and there are multiple instances running. You will be installing the plugin only on the instance you are connected to. It will crash for the users who are connected to other instances.

One simpler solution is to deploy the WordPress website again with the plugin included. It takes away the freedom of installing or un-installing a plugin without a redeployment.

AWS Elastic File System (EFS) is our answer, we will simple mount the plugin directory of WordPress instances to our EFS.

Let’s get our hands dirty folks !!!

Create EFS Service

Select EFS from the service tab of your AWS console and click on Create file system

In the security groups we will add efs Security group.

Note: Please use MAX/IO option optimal performance.

Go ahead and finish creating the EFS setup. It will take few minutes for AWS to create our file system.

In the meantime, we will SSH into our Bastian instance and install few things. Please refer to the Prepare AWS Security Groups for WordPress project Connect to Bastian Instance section to connect.

Once you connect to the bastian instance, run the following commands:

sudo apt-get update

sudo apt-get install nfs-common

mkdir efs
mkdir efs/plugins
mkdir efs/cache

We will use the same EFS for our plugins and cache (for SEO optimization later)

Go to your EFS file system and copy the DNS value.

Run the following command

sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 fs-6f0f3156.efs.ap-southeast-2.amazonaws.com:/ efs

Please replace fs-6f0f3156.efs.ap-southeast-2.amazonaws.com with your own file system DNS name

now run the following command to make sure that the EFS is mounted correctly.

df -h

As I told you earlier, It’ll get easier as we will progress. Our plugins and cache storage in completed !!!!

Create MYSQL database using AWS RDS

Build and Push wordpress project to AWS ECR

Create IAM (User, Roles and Policies)

Salman Sohail — Thu, 26 Dec 2019 13:47:31 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

In this article, we will prepare our IAM User and attach Amazon Elastic Container Registry (ECR) policy to it. It will help us to push our local Dockerized WordPress to AWS ECR.

Other than that, we will create IAM Roles for our Services such as CodeDeploy and CodePipeline so that code is automatically deployed on change.

Create ECR Policy

Login to your AWS console search IAM from the service tab and it will take you to the IAM Management Console. Click on Policies tab and select Create policy

Click on choose a service and select Elastic Container Registry. In the resource section, Select all resources.

Give your policy a name and write that name down somewhere.

Create IAM User

We will now create an IAM User and attach the ECR policy we have create earlier.

From your IAM Management Console. Click on Users tab and select Add user and follow the simple steps to assign the newly created policy to the IAM User.

Finish all the steps until you see the following screen.

Download the CSV file, we need the credentials in that file in order to push our wordpress docker build to AWS ECR in the next article.

Prepare AWS Security Groups for WordPress project

Salman Sohail — Thu, 26 Dec 2019 09:53:54 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

Disclaimer: We will do a lot of configuration in this article. It may look time consuming but it will lay the foundation for all the communication such as WordPress website with MYSQL and Plugins storage.

We will prepare our security groups for AWS Services such as Load Balancer, RDS (MYSQL database), EFS (for plugins storage) and EC2 instances.

I have created these Groups having security in mind, we should not open any unnecessary port on any service.

Our main agenda is to Place Load Balancer on top to face the outside world (people who want to access our wordpress website), Load Balancer will then send that request to any of the instances hosting the WordPress website and respond with content received from the WordPress EC2 instance.

Other than that, WordPress EC2 instance can talk to RDS (MYSQL), EFS (plugins storage) as per required. Please take a look at the following diagram for better understanding of this kind of architecture.

Create Security Groups

We will create the SGs (security groups) for our services so they can talk to each other on the same VPC.

SG for Load Balancer
SG for EC2 instance
SG for RDS (MYSQL)
SG for EFS (storage for plugins)
SG for Bastian host

Login to your AWS console and click on EC2 from the Services menu, we will take notes of the security groups IDS while you create them.

From EC2 console, click on Security groups

Click on Create Security Group

Please make sure all the Security Groups you are creating use the same VPC.

Security Group for Load Balancer

The first Security Group is for the Load Balancer. For outside world, it will enable HTTP (Port 80) in the Inbound Rules. Please select the Inbound tab and click on Add Rule.

Once this SG is created, we will note down its Group ID. which will be used while creating the EC2 instance (WordPress host) SG.

Security Group for WordPress instance

Click on Create Security Group again, we will now create a security group for our EC2 instance where our WordPress project will be deployed. We’ll add an Inbound Rule which will open all the ports for our Load Balancer ONLY.

For that, Add a rule to Inbound with All TCP as type and Custom as the source. Paste the Group ID of the Load Balancer Security group we have created earlier. This will ensure that no one else can access this instance except the Load Balancer.

Hit Create and take a note of Group ID of this SG.

Security Group for Bastian host

We will create an EC2 instance (Bastian host) which we can connect from our local computer to test RDS and EFS or in some cases if we need to connect and troubleshoot our WordPress EC2 instance. This can come in very handy.

This time we will Create a New Security Group with SSH (Port 22) enabled so we can connect to this instance over SSH.

Please create a take a note of Bastian Security Group, we will reference in EFS and RDS SGs

Security Group for EFS and RDS

Now we will create Security Groups for RDS and EFS (enabling Port 3306 and 2049 respectively) and put Group ID of our WordPress and Bastian as a Custom source.

Note: By adding Group ID of Bastian into the Inbound rules of EFS and RDS Security Groups will allow us to configure EFS from Bastian and will also let us connect to RDS (MYSQL) database via Bastian if required.

Most of our work with Security Groups is done here except one more step which is also a good practice for security.

One more tweak and we’re done with SGs I PROMISE.

Please copy the Group ID of the Bastian SG we just created and select the Security Group of our WordPress instance and click on Inbound tab at the bottom. Click Edit to add a new Inbound Rule

Select SSH as type and Custom as Source, now past the Group ID of the Bastian Security Group we created earlier.

By doing this, we add an exception for our Bastian instance so it can connect to our WordPress instance if we want to.

Create Bastian Instance

In the EC2 console, Click on Key pairs and select Create Key Pair.

Give it a and Download the .PEM file on your computer

It is very important to keep this file safe and secure. There is no backup of this file on AWS.

Let’s create our Bastian instance.

Click on Instances from the EC2 console and select Launch instance.

We are using ubuntu 18 with Free tier. Because it is the bastian host and not doing much except enabling us to connect to it from our local machine and to let us connect to the wordpress instance for troubleshooting or testing services.

Select free Tier in instance type section and hit configure instance details at the bottom

In the configure Instance section, make sure you select the same VPC you have used while creating all the Security groups earlier.

Go to next step i.e Add tags and give your instance a name.

In the section below, use the Bastian Security Group you have created earlier which enables port 22 in Inbound rules.

Click on Review and you will see the following screen. Select the Key Pair you have created and it will create the instance for us.

If you will go to instances, you will see that your bastian instance has been created.

Connect to Bastian Instance

Now FINALLY we are about to do something exciting after all this configuration. It’ll only get better from this point TRUST me !!

We have done most of the heavy lifting

Now open your terminal and go the directory where you have downloaded the Key Pair PEM file. Run the following commands

# To protect a file against accidental overwriting. 
chmod 400 wwordpress-key.pem

Once we’re done with the chmod 400. Time to connect to our bastian instance YASSSS !!!!

Click on your bastian EC2 intance and copy the public DNS.

Run the following command from your directory where your PEM file is located.

ssh -i wwordpress-key.pem ubuntu@ec2-3-106-167-129.ap-southeast-2.compute.amazonaws.com

Replace wwordpress-key.pem and ec2-3-106-167-129.ap-southeast-2.compute.amazonaws.com with your Key Pair PEM file name and instance public DNS. You should see the following output on your terminal.

We are now connected to our Bastian Instance via SSH.

Dockerize WordPress with themes, plugins and common configuration

Create IAM (User, Roles and Policies)

High Traffic WordPress website with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series

Salman Sohail — Thu, 12 Dec 2019 10:25:04 +0000

This series will help you with setting up Dockerized WordPress website on you local machine and fully automate the deployment process to Amazon Web Services.

The website will be ready for heavy traffic. To achieve this, I have created the following topics:

WordPress on AWS, the challenges
Dockerize WordPress with themes, plugins and common configuration
Prepare AWS Security Groups for WordPress project
Create IAM (User, Roles and Policies)
Create MYSQL database using AWS RDS
Create AWS EFS (Elastic File System) Plugin storage for WordPress behind Load Balancer
Build and Push wordpress project to AWS ECR
Create Load Balancer for WordPress website
Create Task Definition for WordPress Docker Project
Putting all things together using AWS Task Definition
AWS Codepipeline (Coming soon)
Speed up your WordPress website for better SEO (Coming soon)

I know it sounds a bit harsh saying that WordPress is not civilized enough for AWS but hear me out !

I have been working with modern frameworks such as Rails, Laravel and reactJS for some time now. All these frameworks have evolved so much overtime and ready for multi environments, CI/CD, Load balancers and the list goes on.

Our main product is built on Rails and its fully automated with AWS CI/CD and other automation. Sound great isn’t it?

We recently decided to separate our behind the paywall application and content from each other. In simple words, our complex application (built in Rails) will stay as it is. On the other hand, for content such as blog, marketing pages and few other things such as recipes will be on WordPress.

I will take you through the journey of the whole process and lessons I have learnt during this process of making WordPress shine on AWS with CI/CD, Load balancers and how much WordPress is not ready for that transition by default.

So Let’s make WordPress up its game !

Let’s begin with the challenges I have faced and then you can make the call if these are the right series of tutorials for you or not.

1 | Load balancer and bloody plugins

One simpler solution is to deploy the WordPress website again with the plugin included. It takes away the freedom of installing or un-installing a plugin without a redeployment.

AWS Elastic File System (EFS) is our answer, we will simple mount the plugin directory of WordPress instances to our EFS. Please take a look at the diagram below:

AWS EFS is not just highly available, its IO operations are blazing fast. Don’t worry it won’t slow your website down at all.

2 | Centralized MYSQL Database

Most of the people are probably using AWS RDS already with their WordPress websites. We will be using the same too. Just a centralized database for WordPress website behind Load Balancer.

3 | De-couple variables stored in Database and DO NOT configure the Apache or Ngnix every time

Simple as it sounds, variables such as SITE_URL will not be stored in MYSQL database. You know we always have to configure Apache or Ngninx for the wordpress websites.

A lot of people create/use Amazon Machine Images (AMI) for that purpose. the only problem with using AMI is configuration changes. You will have to create a new AMI on every change you make. Damn what a waste of time.

We will have a boiler plate WordPress Docker template which can kick start any WordPress website in minutes without configuring Apache, Ngnix and other settings.

4 | Website performance and SEO challenges

There are so many plugins available for WordPress website performance boost. I will share the ones I have used and what have worked for us in the end.

5 | AWS Elastic Container Service

Finally, How to use Amazon Elastic Container Service which includes the following:

Amazon Elastic Container Registry (ECR)
- Our Docker build repository that contains our most recent Dockerized WordPress project with all the server configurations
Amazon ECS Task Definitions
- This is where we use our Docker build and put all the variables for our WordPress website; Remember we’re not keeping our website variables in the database.
Amazon ECS Clusters
- This is where it creates the EC2 instances of your WordPress website using the ECS Task Definitions.

Dockerize WordPress with themes, plugins and common configuration

Create MYSQL database using AWS RDS

Salman Sohail — Wed, 11 Dec 2019 05:20:47 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

The purpose of creating MYSQL database using AWS RDS is quite simple. Centralized, automatic backups, scalable and highly available. What else we can ask for when it comes to MYSQL.

For wordpress there are two main options to choose your database from. Amazon Aurora and MYSQL.

Amazon Aurora is also compatible with MYSQL. Aurora is better but more expensive than regular MYSQL RDS database.

In our example, we are using the regular MYSQL

Let’s begin creating the RDS database for our blog

Create RDS Database

Find and select the RDS service under the service tab. Click on create database. Follow the instructions below:

Before we begin, please change things such as database size, names and other identifiers as per your requirements

DB instance identifier is not the database name
Keep the Master username and password secure, we will need it later on.

Keep the Master username and password secure, we will need it later on.

DB instance size totally depends upon your traffic. We’re just using the bare minimum.

In the connectivity section below, use the rds Security Group we have created earlier.

This is where you are creating the initial database.

Create IAM (User, Roles and Policies)

Create AWS EFS (Elastic File System) Plugin storage for WordPress behind Load Balancer

Build and Push wordpress project to AWS ECR

Salman Sohail — Wed, 11 Dec 2019 02:06:18 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

Build and Tag WordPress Docker project

As we have already set up our WordPress Docker project in Dockerize WordPress with themes, plugins and common configuration article. Its time to Tag and push our WordPress project to AWS ECR.

You can also download the Docker WordPress project used in this tutorial series from https://github.com/saluminati/personal-docker-blog

Go to you wordpress project root directory and execute the following commands:


docker build .

You should see something like that on the console

Now we need to tag the build, for that, please run the following command:


docker images

# for you: replace --image-- with your image_id
# replace salman-docker-blog with the name your prefer

docker tag --image-- salman-docker-blog:v0.0.1

Run docker images command and you should see your image tagged properly

Push the Docker build to ECR

Please follow this link to install AWS cli on your local machine.

Once its installed, you should be able to run the following command on your console to configure AWS IAM User credentials you have recently downloaded as a CSV file.

aws configure

Please use the credentials from the CSV file you have downloaded in Create IAM (User, Roles and Policies) article.

It will ask for AWS Key ID, Secret Key and AWS region. Please use the appropriate region.

More information about AWS regions are available here

Create ECR Repository

In this section, we will create a ECR repository on AWS and push our docker build by using AWS cli.

Let’s do this !

Go to AWS service tab and search ECR. Click on create repository.

Make sure you enable Tag Immutability.

Copy the repository URI, we will use it in the next step.

Push to AWS ECR !

Finally !!!! we are now ready to push our Docker build to Amazon AWS

Go to your console and run the following commands:

docker build . -t salman-docker-blog

docker tag salman-docker-blog:latest <repouri>:v1.0.0</repouri>

Please replace the with your ECR repository you have created earlier.

Now your docker image is tagged, time to push it. For that, you will need to run the following command on console to login to AWS ECR service.

aws ecr get-login --no-include-email

This command will print a long string on your console screen. Please copy that long string and paste it to your console again. That will log you in to ECR Service. Once you paste the code and hit enter, you should be able to see Login Succeeded message.

Now to final command

docker push <repouri>:v1.0.0</repouri>

When you will click on your repository in AWS ECR. You will be able to see that version 1.0.0 is being pushed.

Create AWS EFS (Elastic File System) Plugin storage for WordPress behind Load Balancer

Create Load Balancer for WordPress website

Dockerize WordPress with themes, plugins and common configuration

Salman Sohail — Tue, 10 Dec 2019 04:37:29 +0000

This article is the continuation of WordPress with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series. For better understating, please start from the beginning of the series.

In this article, we will create the following files and folders

Let’s create files and folders

Creating Dockfile



touch Dockerfile

Creating development directory and docker-compose file



mkdir development && touch development/docker-compose.yml

Creating themes and plugins directories



mkdir themes && plugins

Creating config directory and uploads.ini file



mkdir config && touch config/uploads.ini

Creating entrypoint-child.sh file



touch entrypoint-child.sh

Dockerfile

Paste the following content into the Dockerfile



FROM wordpress:latest

# Copying Themes and Plugins into the wordpress image
COPY ["themes","/usr/src/wordpress/wp-content/themes"]
COPY ["plugins","/usr/src/wordpress/wp-content/plugins"]

# Updating the configuration of wordpress image with our own
COPY ./config/uploads.ini /usr/local/etc/php/conf.d/uploads.ini

# Applying the execution right on the folders for apache
COPY entrypoint-child.sh /usr/bin/
RUN chmod +x /usr/bin/entrypoint-child.sh
ENTRYPOINT ["entrypoint-child.sh"]
CMD ["apache2-foreground"]

entrypoint-child.sh



#!/bin/bash
set -euo pipefail

echo "Adding permissions"
chown -R www-data:www-data /var/www/html/wp-content &amp;
find /var/www/html/wp-content -type d -exec chmod 0755 {} \; &amp;
find /var/www/html/wp-content -type f -exec chmod 644 {} \; &amp;
echo "Permissions added"

exec docker-entrypoint.sh "$@"

Our WordPress Docker image ( wordpress:latest ) already contains an entry point. which is called docker-entrypoint.sh. The reason have added our custom entrypoint file into the mix is because of AWS EFS volumes for our Plugins storage on AWS. That is why we need some permissions to be added again. This entrypoint just add those permissions and then execute the image default entrypoint. Don’t worry about this for now, I will shed more light on it as we progress.

uploads.ini config

Paste the following content into config/uploads.ini file



file_uploads = On
memory_limit = 64M
upload_max_filesize = 64M
post_max_size = 64M
max_execution_time = 600

Please change the above as per your wordpress website requirements

docker-compose

Paste the following content into development/docker-compose.yml file



version: '3'
services:
  wordpress:
    build: ../
    restart: always
    ports:
      - "8000:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: root
      WORDPRESS_DB_PASSWORD: root
      WORDPRESS_DB_NAME: blog_db_name
      WORDPRESS_CONFIG_EXTRA: |
        /* If you want to add any extra wordpress config */
        # define('WP_ALLOW_MULTISITE', true );
    volumes:
      - wordpress:/var/www/html
  db:
    image: mysql:5.7
    restart: always
    logging:
      driver: none
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_USERNAME: root
      MYSQL_PASSWORD: root
      MYSQL_DATABASE: blog_db_name
    volumes:
      - db:/var/lib/mysql
volumes:
  wordpress:
  db:

We have created two service in the docker-compose file

wordpress
db

WordPress service is building a Docker image from the Dockerfile we have created in the begining



build: ../

The above line is telling the docker-compose to build the image from a Dockerfile which is on the root of this project



ports:
  - "8000:80"

The above command is just mapping the 8000 port from outside world to the port 80 of this container

We are also setting some environment variables such as database credentials which are initialized in the db service

Time to see something on the browser !!!

All the required files and directories have been created. Let’s start our wordpress website by running the following commands



cd development
docker-compose build
docker-compose up

Open your web browser and type http://localhost:8000 and you should be able to see this page.

Prepare AWS Security Groups for WordPress project

AWS – Using Multiple (Staging, UAT and Production) Accounts Under AWS Organization

Salman Sohail — Tue, 10 Dec 2019 04:11:18 +0000

This article assumes that you want to have separate AWS console accounts such as Staging, UAT and Production at one place.

The best way to achieve this kind of separation is by using AWS Organizations and AWS Single Sign-On (SSO)

AWS Organizations provides all the necessary options to achieve this goal.

Okay enough talk, Lets do this !

Create Organization

Search AWS Organization in the service tab and then create your organization

You will receive a confirmation email soon. Once you verify your master account, You’re good to go !

Add/Invite AWS accounts

You can associate an existing AWS account to your organization or you can create a new one.

In our example we will create a new one by clicking on Add Account

You can also use Organizational Units (OUs) for more hierarchical structure. We will use a simpler approach in our example which can be easily transformed into OUs in the future.

This is our structure for now

Now lets start by adding these accounts into your organization

Choose Create account and fill Full Name (Staging, dev and production etc) and Email, leave the IAM role name for now ( we will add roles and policies on the AWS Accounr level later )

Repeat the same for each account you want to create such as Staging, UAT and Production

AWS Single Sign-On (SSO)

From services tab select AWS Single Sign-On (SSO) and click on Enable AWS SSO. Once its enabled, you should be able to see the following options

Lets start with the first step Choose your identity source. You can click on that option and change the User portal URL. This will be a portal page for your team to login and select the AWS account they are associated with.

Users and Groups

Now lets create Users and Groups that we can associate with AWS accounts later on.

Click on the Users on the left and select Add User

Fill in all the details and leave Groups as it is for now.

Add as many users you want to add by repeating the same steps.

Lets create our Groups now. In my case I have created Development and Production groups

Time to assign the Users to the Groups. Click on the Users tab and select the user you want to associate with a group. Once you select the user, you’ll be able to see Groups tabs

Click on Add to group and assign the user to one or multiple groups

AWS Accounts

This is the final step I PROMISE. Its time to associate the users with the AWS accounts ( You have created in the organization ). For that you need to click on AWS account tab on the left.

Click on the on the desired AWS account and select Assign Users

Select the Groups tab and choose the User’s group you want to associate with this Account. Click on Next: Permission set

Click on Create new permission set. You have have two options to choose from on the next page. In our example, we are selecting Use an existing job function policy and the AdministratorAccess policy.

You can create a custom permission set as per your policies if you want

On the final page, tick on the permission set you just have created and hit Finish YEAYYYYYYYY !!!!!!!

When you go to the portal ( created earlier in the post ). You will see login screen.

You can click on the Management console of any AWS account and Bingo. you’re in that environment’s AWS account !

DEV Community: Salman Sohail

Creating a Ruby gem using Thor generator

Let’s do this!

Install thor

Getting started

Some explanation – As I promised

Content of gem_generator.thor file

Putting all things together using AWS Task Definition

Create ECS Cluster

Step 1: Select Cluster template

Step 2: Configure cluster

Add Service to your Cluster

Adding Load Balancer

Configure Autoscaling Group

Creating Scale UP and Scale Down policies.

Service and Task Tabs

Sucess !!!!

Troubleshooting

Create Task Definition for WordPress Docker Project

Before we began

Create Task Definition

Step 1: Select launch type compatibility

Step 2: Configure task and container definitions

Environment

AWS Logs

Volumes for Cache and Plugins

Previous

Next

Create Load Balancer for WordPress website

Step: Configure Load Balancer and VPC

Step: Configure Security Groups

Step: Configure Routing (Target Group)

Previous

Next

Create AWS EFS (Elastic File System) Plugin storage for WordPress behind Load Balancer

Why do we need to use EFS for plugin storage

Create EFS Service

Previous

Next

Create IAM (User, Roles and Policies)

Create ECR Policy

Create IAM User

Prepare AWS Security Groups for WordPress project

Create Security Groups

Security Group for Load Balancer

Security Group for WordPress instance

Security Group for Bastian host

Security Group for EFS and RDS

Create Bastian Instance

Connect to Bastian Instance

Previous

Next

High Traffic WordPress website with Docker, AWS (ECS, Code Pipeline, Load Balancer, RDS, EFS) Complete Series

1 | Load balancer and bloody plugins

2 | Centralized MYSQL Database

3 | De-couple variables stored in Database and DO NOT configure the Apache or Ngnix every time

4 | Website performance and SEO challenges

5 | AWS Elastic Container Service

Next

Create MYSQL database using AWS RDS

Create RDS Database

Previous

Next

Build and Push wordpress project to AWS ECR

Build and Tag WordPress Docker project

Push the Docker build to ECR

Create ECR Repository

Push to AWS ECR !

Previous

Next

Dockerize WordPress with themes, plugins and common configuration

Dockerfile

entrypoint-child.sh

uploads.ini config

docker-compose

Time to see something on the browser !!!

Next

AWS – Using Multiple (Staging, UAT and Production) Accounts Under AWS Organization

Create Organization

Add/Invite AWS accounts