Deploying HAProxy Load Balancer and webserver over AWS EC2 using Ansible

Published by Anubhav Singh on October 15, 2020

In this article, we are going to set Apache webserver and HAProxy load balancer over AWS using the Ansible automation tool. Before going to learn this article you must have some basic knowledge about the Ansible. You can refer to my previous blogs for that and also you can learn how to set up that in your RedHat 8 or CentOS 8 operating system.

What is Ansible and How it is so Powerful?

How to install Ansible on RHEL8?

After having some basic knowledge about Ansible you also have some knowledge about HAProxy Loadbalancing as well.

Load Balancing

Load balancing is a technique of distributing networks over different servers. This ensures that no single server will have to bear all the traffic. It maintains the record of every server and sends traffic to all the network evenly. It solved many use cases of today like high availability of data and less latency time and better responsiveness.

HAProxy

HAProxy is a free open source software that provides a high availability load balancer and proxy server for the TCP and HTTP applications for Linux, Solaris, and FreeBSD. It’s the most common use to distribute the workload over multiple servers. By using this we get rid of the non-availability of the servers and also reduce the latency for the high traffic webserver’s.

In today’s production environment this software has a great demand where thousands of servers are running but providing the same content over the same URL to a huge amount of people is really a tough task. This HAProxy uses the load balancing technique and solves all the big use cases. To know more you can follow this article.

Let’s come to our task for today

Task Description

Create an Ansible playbook of different roles that deploys an HAProxy load balancer and multiple webservers on AWS.

• Provision EC2 instance.
• Retrieve IP addresses using the dynamic inventory concept.
• Configure the webserver.
• Configure the HAProxy load balancer.
• The target node of the webserver should auto-update.

Code

It’s good to check that Ansible is installed or not and for that, we can use ansible –version.

In order to complete the task, I have created three different playbooks:

task3– To deploy the instance and respective key-pairs and security groups.

webserver- To provision the apache webserver 

lb – To provision the load balancer  

Provision EC2 instance

In this, I created a key pair and two security groups(one for webserver and other for HAProxy) and 3 EC2 instances one for the load balancer and the other for webservers.

---
# tasks file for task3

- name: Create Key Pair
  ec2_key:
      name: task3key
      aws_region: "{{ region }}"
  register: ec2_key
- name: Copy Key to Local File
  copy:
      content: "{{ ec2_key.key.private_key }}"
      dest: "{{ key_dest }}"
      mode: '0600'
- name: Create Security Group - Allow SSh, HTTP
  ec2_group:
      name: task3_web_sg
      description: sg for web inventory
      region: "{{ region }}"
      rules:
      - proto: tcp
        from_port: 80
        to_port: 80
        cidr_ip: 0.0.0.0/0
      - proto: tcp
        from_port: 22
        to_port: 22
        cidr_ip: 0.0.0.0/0
      rules_egress:
      - proto: all
        cidr_ip: 0.0.0.0/0
  register: task3_web_sg
- name: Create Security Group - Allow SSh, HAProxy
  ec2_group:
      name: task3_lb_sg
      description: sg for lb inventory
      region: "{{ region }}"
      rules:
      - proto: tcp
        from_port: 8080
        to_port: 8080
        cidr_ip: 0.0.0.0/0
      - proto: tcp
        from_port: 22
        to_port: 22
        cidr_ip: 0.0.0.0/0
      rules_egress:
      - proto: all
        cidr_ip: 0.0.0.0/0
  register: task3_lb_sg
- name: Launch EC2 Instance for webserver
  ec2:
      key_name: task3key
      instance_type: t2.micro
      image: "{{ image_id }}"
      wait: yes
      region: "{{ region }}"
      count: 2
      vpc_subnet_id: "{{ subnet }}"
      group_id: "{{ task3_web_sg.group_id }}"
      assign_public_ip: yes
      state: present
      instance_tags:
        Name: webserver
  register: web
- name: Launch EC2 Instance for lbserver
  ec2:
      key_name: task3key
      instance_type: t2.micro
      image: "{{ image_id }}"
      wait: yes
      region: "{{ region }}"
      count: 1
      vpc_subnet_id: "{{ subnet }}"
      group_id: "{{ task3_lb_sg.group_id }}"
      assign_public_ip: yes
      state: present
      instance_tags:
        Name: lbserver
  register: lb
- name: Refresh Inventory File
  meta: refresh_inventory
- pause:
    minutes: 2

Here I created the key pair and two security groups on for webserver allowing Http port 80 and other for HAProxy allowing port 8080. We also added to refresh the inventory option so that after the creation of an instance the inventory file dynamically fetches the IP.

Configuring the webserver

<pre class="wp-block-syntaxhighlighter-code">- name: Install Required Package
  package:
    name: python3
    state: present
  become: true
- name: Install Apache Server
  package: 
    name: httpd 
    state: present
  become: true
- name: Copy webpage
  get_url:
    dest: "/var/www/html"
    url: "<a href="https://raw.githubusercontent.com/anubhavsinghgtm/aws-ansible-dynamic-inventory/master/index.html">https://raw.githubusercontent.com/anubhavsinghgtm/aws-ansible-dynamic-inventory/master/index.html</a>"
  become: true
- name: Start Apache Service
  service: 
    name: httpd 
    state: started
  become: true</pre>

This helps to set up the Apache webserver and start the service as well.

Configuring HAProxy webserver

- name: install haproxy software
  package:
    name: "haproxy"
    state: present
  become: true 
- name: copy my conf file of lb
  template:
    src: "haproxy.cfg"
    dest: "/etc/haproxy/haproxy.cfg"
  become: true
- name: start service lb
  service:
    name: "haproxy"
    state: started
  become: true

This helped to provision the HAProxy load balancer and done.

All the roles are created successfully. Now, we will create a playbook that will run all of the above.

- hosts: localhost
  roles:
          - task3
- hosts: tag_Name_webserver
  remote_user: ec2-user
  roles:
          - webserver
- hosts: tag_Name_lbserver
  remote_user: ec2-user
  roles:
          - lb

Once the code is done let’s run this playbook and have a look at the output

use ansible-playbook task3.yml

security groups:

Instances:

Our setup is ready. Let’s look run our system and get the output.

Our Output:

Hurrah!!! We have successfully completed this. Our load balancer is working fine showing the output of our webserver to our client. In this task, I have used only two instances but in real industry use cases, we can extend the number of instances and can manage the whole server accordingly.

Stay tuned with us for more such amazing tasks. You can also follow us on our social media handle so that you never miss our future updates.

Sharing is caring and hence share this task with your friends and help them to grow.

In case of any query, you can comment down below or can connect with the author on other social platforms like

Linkedin  Twitter