Forem: Toluwalope Aiyegbusi

Helmify your React App on EKS

Toluwalope Aiyegbusi — Thu, 30 Mar 2023 11:40:05 +0000

Introduction

This article gives a step-by-step explanation of how to deploy a react app using Helm charts on EKS. The react app is a simple app that prints the current date and time.

Helm Chart is an open-source project owned by Kubernetes. It is Package Manager, Template Engine and Release engine for Kubernetes.

Prerequisites

An AWS Account and IAM User with necessary role or Admin
Have docker installed
Have eksctl installed. Eksctl is the official command line for EKS
Have Helm installed.

Getting the Application Source Code

Clone the repository for the tutorial.



git clone https://github.com/ToluwalopeAyo/demo-react-app.git

To run the app locally, switch to the directory, install dependencies and start the app.



cd reactapp
npm install
npm start

A new tab should open on your browser with the app running.

Containerize the App

In the working directory, create a Dockerfile and paste the following.



FROM node:16-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD [ "npm", "start" ]

To build the docker image, run the command below. Replace 'name' with a preferable name tag for your docker image.



docker build -t <name> .

Push Docker Image to a Container Registry

In this tutorial, we'd use Elastic Container Registry to publish the docker image.

First, log in to AWS console and search for the Elastic Container Registry Service.
Click on 'Create Repository' to create a repository for the docker image. The repository is to be private and give the repository a name.

Then, authenticate your docker client with ECR with this command:



aws ecr get-login-password --region region | docker login --username AWS --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com

Replace 'region' and 'aws_account_id' with your AWS region and AWS account id respectively.
You should get a response with the message "Login Succeeded".

Tag the docker image that was created earlier with the uri of the ecr repository and a verison tag.



docker tag <name> aws_account_id.dkr.ecr.region.amazonaws.com/repository-name

Push the docker image to ECR



docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository-name

Create the EKS Cluster

Using the Eksctl command, create a kubernetes cluster. Replace 'region' with your appropriate region.



eksctl create cluster --name helm-test --region <region> --nodegroup-name linux-nodes --node-type t2.micro --nodes 2

The cluster should take about 20 mins to create completely.

Create the Helm Chart

To create a new chart, run the helm create command in the react-app directory, where 'helm-test' is the name of the chart. This command creates a directory containing the common chart files and directories.



helm create helm-test

The file structure should look like this:

In the helm-test folder, delete all the files in the templates folder except the _helpers.tpl file. Also clear the values.yaml file. You can copy the files in a seperate directory for reference.

In the templates folder, create a deployment.yaml file and paste the code below.



apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "helm-test.fullname" . }}
  labels: 
    # replaces this value with the chart name
    app: {{ include "helm-test.name" . }}
spec:
  # this gets the value of replicas from the values.yaml file
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ include "helm-test.name" . }}
  template:
    metadata:
      labels:
        app: {{ include "helm-test.name" . }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        # gets the image repository value from the values.yaml file
        image: {{ .Values.image.repository }}
        imagePullPolicy: {{ .Values.image.pullPolicy}}
        ports:
        - containerPort: 3000

In the templates folder, create a svc.yaml file and paste the code below.



apiVersion: v1
kind: Service
metadata:
  labels:
    app: {{ include "helm-test.name" . }}
  name: {{ include "helm-test.name" .}}
spec:
  type: {{ .Values.service.type }}
  selector:
    app: {{ include "helm-test.name" .}}
  ports:
  - port: {{ .Values.service.port }}
    targetPort: {{ .Values.service.targetPort }}

In the values.yml file, paste the code below. Make sure to replace 'aws_account_id', 'region' and 'repository-name' with the appropriate value.



replicaCount: 1

image:
  repository: <aws_account_id>.dkr.ecr.<region>.amazonaws.com/<repository-name>:latest
  pullPolicy: IfNotPresent

service: 
  port: 80
  targetPort: 3000
  # The service type is a LoadBalancer so that we can access it from the browser
  type: LoadBalancer

Run the helm lint . command to be sure that the charts are well formatted. The output should look like this:

Deploying the Helm Charts to Kubernetes

To deploy the helm chart to kubernetes, run the 'helm install' command



helm install helm-test .

The output should look like this:

To confirm that the app was successfully deployed, run the kubectl get pods and get svc command.



kubectl get pods

The pod should be running



kubectl get svc

Copy the endpoint in the External IP and paste on your browser using http and you should see that the app is running.

Conclusion

In this article, we learnt how to use Helm Charts to deploy a react app to Kubernetes.

In order not to incur charges on AWS, please make sure to delete the EKS cluster.
First delete the helm chart.



helm uninstall helm-test

Then delete the cluster.



eksctl delete cluster --name helm-test --region <region>

Thank you

Ansible as a Provisioning tool: Creating a VPC

Toluwalope Aiyegbusi — Tue, 28 Mar 2023 22:23:42 +0000

Introduction

Ansible is an open-source command-line IT automation software application sponsored by RedHat.

It is mostly used as a server configuration management tool, network automation tool and can also be used for provisioning
several services like kubernetes, nginx and services across several cloud platforms. Check the official documentation to see a list supported services.

This article gives a run-down of how to build an AWS VPC without having to use the AWS console using Ansible. The VPC would contain a private and public subnet, internet gateway for the public subnet, a Nat gateway for the private subnet, and route tables.

Prerequisites

An AWS account
An AWS user with an IAM role that has the necessary permissions to create resources, mostly an admin role.
Should have ansible installed. Click here for installation guide

Setting up the project directory

Create a directory where you would have your project set up. In the working directory,create a network.yml file and a vars folder with a main.yml file in it. The vars folder will contain environment variables. Your directory structure should look like this:

├── network.yml
└── vars
    └── main.yml

Variables

The use of variables is to ensure flexibility within the main playbook in case of repeated values and you can easily modify values without modifying the main file.
Copy and paste this into the main.yml file in the vars folder. Make sure to replace the "aws_secret_key" and "aws_access_key" with yours. Although it is not advisable to hard code secret keys into variable files, check the documentation on how to use best practices to store credentials

aws_secret_key: ""
aws_access_key: ""
region: us-east-1 
vpc_cidr: 10.1.0.0/16
public_subnet_cidr: 10.1.1.0/24
private_subnet_cidr: 10.1.2.0/24

Creating the VPC

Copy and paste this code into the network.yml file

- name: Create VPC and Subnets
  hosts: localhost
  # This is to make sure the playbook references the variables in the vars folder
  vars_files:
    - vars/main.yml
  module_defaults:
    group/aws:
      aws_secret_key: "{{ aws_secret_key }}"
      aws_access_key: "{{ aws_access_key }}"

  tasks:
    - name: Create a VPC
      amazon.aws.ec2_vpc_net:
        name: test
        state: present
        cidr_block: "{{ vpc_cidr }}"
        region: "{{ region }}"
        dns_hostnames: true
        dns_support: true
        tags:
          key: name
          value: dev
      # the 'register' keyword here is to register the module returned data in the 'vpc_name' variable
      register: vpc_name

    - name: Create Public Subnet
      amazon.aws.ec2_vpc_subnet:
        state: present
        vpc_id: "{{ vpc_name.vpc.id }}"
        region: "{{ region }}"
        cidr: "{{ public_subnet_cidr }}"
        map_public: true
      register: public_sub

    - name: Create Private Subnet
      amazon.aws.ec2_vpc_subnet:
        state: present
        vpc_id: "{{ vpc_name.vpc.id }}"
        region: "{{ region }}"
        cidr: "{{ private_subnet_cidr }}"
        map_public: true
      register: private_subnet

    - name: Create Internet Gateway
      amazon.aws.ec2_vpc_igw:
        vpc_id: "{{ vpc_name.vpc.id }}"
        region: "{{ region }}"
        state: present
      register: igw

    - name: Public Subnet Route Table
      amazon.aws.ec2_vpc_route_table:
        vpc_id: "{{ vpc_name.vpc.id }}"
        region: "{{ region }}"
        subnets:
          - "{{ public_sub.subnet.id }}"
        routes:
          - dest: 0.0.0.0/0
            gateway_id: "{{ igw.gateway_id }}"
      register: public_route_table

    - name: Elastic IP for Nat gateway
      amazon.aws.ec2_eip:
        region: "{{ region }}"
        state: present
      register: eip

    - name: Network gateway
      amazon.aws.ec2_vpc_nat_gateway:
        state: present
        subnet_id: "{{ private_subnet.subnet.id }}"
        eip_address: "{{ eip.public_ip }}"
        region: "{{ region }}"
        wait: true
      register: nat

    - name: Private subnet route table
      amazon.aws.ec2_vpc_route_table:
        vpc_id: "{{ vpc_name.vpc.id }}"
        region: "{{ region }}"
        subnets:
          - "{{ private_subnet.subnet.id }}"
        routes:
          - dest: 0.0.0.0/0
            gateway_id: "{{ nat.nat_gateway_id }}"

Run the playbook

Open the terminal in the working directory and run the command

ansible-playbook network.yml

The output should look like this

PLAY [Create VPC and Subnets] **************************************

TASK [Gathering Facts] *********************************************
ok: [localhost]

TASK [Create a VPC] ************************************************
changed: [localhost]

TASK [Create Public Subnet] ****************************************
changed: [localhost]

TASK [Create Private Subnet] ***************************************
changed: [localhost]

TASK [Create Internet Gateway] *************************************
changed: [localhost]

TASK [Public Route Table] ******************************************
changed: [localhost]

TASK [Elastic IP for Nat gateway] **********************************
changed: [localhost]

TASK [Network gateway] *********************************************
changed: [localhost]

TASK [Private subnet route table] **********************************
changed: [localhost]

PLAY RECAP *********************************************************
localhost                  : ok=9    changed=8    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

You can log in to the AWS console and be sure it created successfully

Conclusion

That's it on how to use Ansible to create a VPC. In my next article, I'll show how to delete the resources created using Ansible.