Forem: Leju B

"Automating App Deployment on AWS with Ansible: A Case Study"

Leju B — Tue, 03 Sep 2024 04:48:22 +0000

Introduction

In the world of DevOps, automation is key to ensuring that deployments are repeatable, efficient, and free from human error. Recently, I completed a project where I automated the deployment of a Node.js application on AWS using Ansible. This application allows users to input their name, email, and upload a profile picture. The application then stores the photo in an S3 bucket and the name and email in an RDS MySQL database.
In this blog post, I'll walk you through the project, the challenges I faced, and the key learnings I gained along the way.
- -

Project Overview

The primary goal of this project was to automate the deployment of a Node.js application on AWS. The application handles user data by storing profile pictures in S3 and user information in RDS. The deployment was automated using Ansible, a powerful tool for Infrastructure as Code (IaC).
Tech Stack:

Frontend: Node.js
Backend: AWS RDS, S3
Automation Tool: Ansible
Deployment Platform: AWS EC2
Web Server: NGINX - -

Deployment Process

1. Setting Up the EC2 Instance
To begin, I launched an EC2 instance using AWS and configured security groups to allow HTTP/HTTPS traffic. This instance served as the host for the application.
2. Deploying the Node.js Application
Next, I uploaded the Node.js application to the EC2 instance. I used Vite as the build tool, which provided a fast and optimized development experience. After building the app for production, I installed the necessary dependencies and prepared the environment for deployment.
3. Installing and Configuring NGINX
NGINX was installed on the EC2 instance to serve the Node.js application. The server was configured to act as a reverse proxy, forwarding requests to the application.
This configuration ensures that all incoming requests are routed correctly to the Node.js application.
4. Automating with Ansible
The entire deployment process was automated using Ansible. I created Ansible playbooks to:

Provision the EC2 instance
Set up and configure the S3 bucket and RDS MySQL database
Deploy the Node.js application
Install and configure NGINX
Set up environment variables and manage application secrets using a .env file Ansible roles were used to modularize the tasks, making the automation process more efficient and scalable. - -

Challenges and Solutions

1. Environment Configuration:
**Configuring the environment variables correctly was critical to ensuring that the application could securely connect to the AWS services. I used Ansible to create a .env file with the necessary credentials and connection strings.
**2. AWS Service Integration:
Integrating the application with AWS RDS and S3 required careful handling of permissions and network settings. Ansible made it easier to manage these configurations across different environments.
3. NGINX Configuration:
Setting up NGINX to serve the nodejs application required configuring it as a reverse proxy. Debugging issues with the NGINX configuration was a key learning experience, particularly in managing static files and ensuring that all routes were correctly handled.
4. Ansible playbook:
Setting up ansible playbook to configure the app for performing the applications backend configuration automatically. Ansible playbook runs on the Master server and performs or executes the program in the worker servers in this case only one server.
Check out the complete documentation and the codes in my GitHub Repo.
- -

Key Learnings

1. Ansible for Automation:
This project deepened my understanding of Ansible's capabilities in automating complex deployments. By structuring the playbooks and roles correctly, I was able to create a reusable and scalable automation process.
2. AWS Integration:
Gaining hands-on experience with AWS services like EC2, S3, and RDS was invaluable. Understanding how to securely integrate these services with an application is a crucial skill in modern cloud development.
3. Infrastructure as Code (IaC):
The project reinforced the importance of IaC principles, allowing for consistent and repeatable deployments across different environments.
- -

Conclusion and Future Plans

Automating the deployment of this Node.js application on AWS was a challenging yet rewarding experience. The project provided me with a deeper understanding of both cloud infrastructure and automation tools. Moving forward, I plan to explore more advanced CI/CD pipelines and enhance the application's features and security.
Interested in the technical details? You can find the full documentation and playbooks in my GitHub repository. If you have any questions or would like to discuss the project further, feel free to connect with me!

Automating EC2 Instances with AWS Lambda and CloudWatch

Leju B — Wed, 28 Aug 2024 06:01:50 +0000

Introduction:

I recently completed a project where I automated the start and stop of EC2 instances using AWS Lambda and CloudWatch EventBridge. Here's a quick overview of how I did it.

Step-by-Step Guide:

IAM Setup:

Created custom IAM policies to grant permissions for starting and stopping EC2 instances.
Set up roles to securely attach these policies to Lambda functions.

Lambda Functions:

Developed two Python scripts using Boto3 to manage the EC2 instances.
Configured the Lambda functions to use the appropriate IAM roles.

Automating with CloudWatch:

Created CloudWatch EventBridge rules to trigger the Lambda functions based on a cron schedule.

Challenges and Solutions:

While working on this project, I encountered a few challenges, such as troubleshooting IAM permissions and Lambda execution errors. Through persistence and a bit of troubleshooting, I was able to resolve these issues and ensure the automation worked flawlessly.

Conclusion:

This project was a great opportunity to explore AWS's automation capabilities. If you're interested in trying it out yourself, check out the full documentation and code in my GitHub repository!

Ckeckout the repo

React Vite App Deployment on EC2 with NGINX: A Step-by-Step Guide

Leju B — Fri, 23 Aug 2024 09:25:22 +0000

Deploying a React Vite application on an Amazon EC2 instance can be a great way to get hands-on experience with cloud infrastructure and web server management. In this guide, I'll walk you through the process of deploying a basic Airbnb clone built with React and Vite, and show you how to use NGINX to serve your application efficiently.

Project Overview

This project involved cloning a basic Airbnb clone using React and Vite, which was then deployed on an Amazon EC2 instance. The primary goal was to understand the deployment process and learn how to configure NGINX to manage and run the application in the background.

Deployment Process

1. Setting Up the EC2 Instance:
Launch an EC2 instance on AWS.
Configure security groups to allow HTTP/HTTPS traffic.

2. Deploying the React Vite App:

Clone or fork the GitHub repo : git clone https://github.com/leju-b/AirBnb-Clone-deployed-EC2
Install npm : sudo apt install npm
Install other dependencies
Build the app using : npm install
Run the app for preview : npm run dev

Allow inbound rules for port 3000 if the app is running in that port

3. Installing and Configuring NGINX:
Installed NGINX on the EC2 instance to serve the application.
Edited the NGINX configuration file to point to the React app's dist folder and set up the server block.

4. Verifying the Deployment:
Tested the NGINX configuration and reloaded the service.
Accessed the application using the public IP address of the EC2 instance.

NGINX Configuration Details

The NGINX configuration file can be found in /etc/nginx/nginx.conf, and site-specific configurations are usually located in /etc/nginx/sites-available/. Here's a snippet of the configuration used for this project:

server {
    listen 80;
    server_name your_domain_or_public_ip;
    root /path/to/your/react-vite-app/dist;
    index index.html;
    location / {
        try_files $uri $uri/ /index.html;
    }
    error_log /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
}

Troubleshooting Tips
If NGINX throws an error, check the logs in /var/log/nginx/error.log.
Ensure the dist folder is correctly located and accessible by NGINX.

Conclusion and Future Plans
Deploying this application was an insightful experience, particularly in understanding the relationship between build tools like Vite, cloud platforms like AWS, and web servers like NGINX. Moving forward, I plan to enhance the application's features, add HTTPS for secure connections, and implement CI/CD pipelines to automate the deployment process.
If you're interested in learning more about deploying React apps or have any questions about the process, feel free to connect with me!

Trying Out AWS Amplify for the first time.

Leju B — Tue, 20 Aug 2024 14:15:57 +0000

Introduction:

Hello, everyone! I recently completed a project where I deployed a basic static web page which I built earlier with Vite+React on AWS Amplify. This was a straightforward project, but it provided valuable insights into cloud deployment and the power of AWS Amplify. This project was an exciting step in my DevOps journey, where I got to explore AWS Amplify for the first time. In this post, I’ll walk you through the process and share what I learned.

1. Project Overview

This project involved creating a simple static web page using Vite and React. The focus was on building a lightweight, fast-loading page. Here’s a quick overview of the key components:

Vite + React Development: The web page was developed using Vite and React, making it lightweight and fast. It’s a basic project, but it provided a great opportunity to practice my React skills.

AWS Amplify Deployment: I deployed the app on AWS Amplify, which I was exposed to during my training at AK Infopark Nagercoil. Amplify’s integration with GitHub allowed for automatic deployment whenever changes were made to the repository — making the process incredibly smooth. It’s a simple task, but there are more complex configurations in amplify. I have tried the automatic deployment by authenticating with GitHub as well as the manual upload which I found not a good practice, because of the lack of CI/CD.

CI/CD Pipeline: The seamless integration between GitHub and AWS Amplify ensured that any changes in the code were automatically deployed, giving me hands-on experience with continuous integration and continuous deployment. I took the time to learn about the process between GitHub and Amplify and I felt so fascinated by how a simple deployment is leveraging CI/CD.

2. Challenges & Solutions

While the project was basic, it came with its own set of challenges:

Setting Up Amplify: Authenticating AWS Amplify with my GitHub account was a new experience, but it provided a smooth workflow for continuous deployment.

Learning from Training: I first learned about AWS Amplify during my training at AK Infopark Nagercoil, and this project was my first hands-on experience applying that knowledge.

3. Key Learnings

Here are some of the key takeaways from this project:

CI/CD in Action: Implementing a CI/CD pipeline through AWS Amplify was a great way to experience continuous integration and deployment in real-time.

Hands-On with AWS Amplify: Deploying a static site gave me practical experience with cloud services and reinforced the concepts I’ve been learning in my DevOps journey.

4. Reflecting on the Experience

Deploying this static web page was a small but significant step in my learning journey. It taught me the importance of automation and cloud services in modern web development. I’m excited to continue this journey and apply these concepts to more complex projects.

Conclusion:

This project was a great way to start exploring cloud deployment with AWS Amplify. If you are interested in DevOps, cybersecurity, web development technologies, cloud, or tech overall. let’s connect and share our experiences!

DevOps #AWSAmplify #Vite #React #CI/CD #StudentJourney #ContinuousLearning

Building and Deploying My Personal Portfolio Using React & Node.js

Leju B — Sun, 18 Aug 2024 12:25:05 +0000

Introduction:

Hello, everyone! In my latest project, I created and deployed a personal portfolio website using React and Node.js. This project allowed me to not only showcase my skills and projects but also gain hands-on experience in deploying and managing a personal website. In this post, I’ll walk you through the process and share what I learned along the way.

1. Project Overview

The goal of this project was to build a dynamic and responsive personal portfolio where I could showcase my skills, projects, and learning journey. Here’s a quick overview of the key components:

Frontend with React: I used React to build the frontend, taking advantage of its component-based architecture to create a clean and responsive user interface.
Backend with Node.js: For the backend, I used Node.js, which provided a flexible environment for handling server-side logic and integrating any additional functionalities.
Deployment on GitHub Pages: I chose GitHub Pages as the hosting platform, which allowed for easy and automatic updates every time I pushed new changes to the repository.

2. Challenges & Solutions

Every project comes with its own set of challenges. Here’s how I tackled a few during this one:

GitHub Pages Configuration: Configuring GitHub Pages to work seamlessly with my custom domain and React app required some research, but once set up, it provided a reliable and easy-to-manage hosting solution.
Responsive Design: Ensuring the portfolio was fully responsive and looked great on all devices was a key challenge. I focused on media queries and flexible layout design to achieve this.

3. Key Learnings

Here are some of the valuable lessons I learned from this project:

Deploying with GitHub Pages: This project was my first experience deploying a site with GitHub Pages, and it taught me how to automate deployments and manage a live site.
Version Control Practices: Working with Git to manage updates and ensure that the site was always up-to-date was a great exercise in version control best practices.
Responsive Web Design: I gained more experience in making web designs responsive, ensuring that the site provides a great user experience across different devices. ### 4. Reflecting on the Experience

Creating and deploying this personal portfolio was a rewarding experience that solidified my understanding of web development and deployment. I’m excited to keep updating the portfolio with new projects and insights as I continue my learning journey.

Conclusion:
Building this portfolio was a great way to apply what I’ve learned so far in my DevOps journey. It’s an ongoing project that I plan to keep updating. If you’re also working on a portfolio or have experience with React, Node.js, or GitHub Pages, let’s connect and share insights!

Link to portfolio page
link to GITHUB_REPO

DevOps #React #NodeJS #GitHubPages #WebDevelopment #CI/CD #ContinuousLearning

Starting My DevOps Journey: A 3-Hour Course That Changed Everything

Leju B — Sat, 17 Aug 2024 19:42:25 +0000

Hello everyone! I'm a computer science student with a passion for DevOps and cybersecurity. Recently, I completed a 3-hour DevOps course that completely transformed my approach to technology. In this post, I'll share what I learned and how it set the stage for my ongoing projects.

Course Overview: The 3-hour course provided me with valuable insights and practical knowledge. It covered the basics of DevOps, including its culture, key practices, and essential tools. Here's a breakdown of what I learned:

DevOps Culture: I learned about the importance of collaboration between development and operations teams, which is at the heart of DevOps.
Continuous Integration & Deployment (CI/CD): The course introduced me to the concepts of CI/CD, which ensure that code changes are continuously integrated and deployed without manual intervention.
Automation: The course highlighted the significance of automation in DevOps, which reduces human error and speeds up processes.

Hands-On Experience with DevOps Tools: I had the opportunity to gain hands-on experience with some of the most important tools in the DevOps toolkit:

Git: I learned how to use Git for version control, which is crucial for managing code changes in a collaborative environment.
Jenkins: The course introduced me to Jenkins, an automation server that facilitates continuous integration and deployment.
Docker & Kubernetes: I got a taste of containerization with Docker and orchestration with Kubernetes, two powerful tools that are transforming how applications are deployed and managed.

How This Course Shaped My Journey:
This course was more than just an introduction—it laid the foundation for my current projects. It gave me the confidence to explore more complex topics like infrastructure as code, automation, and cloud computing. Since completing the course, I've been working on several projects that I'll be sharing in future posts.
What's Next?
I'm excited to continue this journey and share more about the projects I've completed, including setting up an Automated Infrastructure Stack with Ansible and AWS, building a travel journal app, and more. Each project has been a learning experience that builds on what I learned in this course.

Conclusion:
This 3-hour course was a pivotal moment in my DevOps journey, and I'm eager to continue learning and growing. If you're also passionate about DevOps or just starting out, let's connect and share our experiences!