```
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1733744723302/f60307a0-965e-4ec1-b179-613c235858f3.png align="center")
---
> Terraform steps done ,now going to setup with ansible
---
# 5\. Creating dynamic inventories in ansible dir
> Firstly nevigate to ansible dir which would you have created before
---
### **Step 1: Create the Inventories Directory**
```bash
mkdir -p inventories/dev inventories/prod inventories/stg
```
### **Step 2: Add Inventory Content for Each Environment**
#### **For** `inventories/dev`:
```ini
[servers]
server1 ansible_host=3.249.218.238
server2 ansible_host=34.241.195.105
[servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/home/amitabh/devops-key
ansible_python_interpreter=/usr/bin/python3
```
#### **For** `inventories/stg`:
```ini
[servers]
server1 ansible_host=34.244.89.121
server2 ansible_host=34.242.151.189
[servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/home/amitabh/devops-key
ansible_python_interpreter=/usr/bin/python3
```
#### **For** `inventories/prod`:
```ini
[servers]
server1 ansible_host=3.252.144.3
server2 ansible_host=63.34.12.124
server3 ansible_host=34.244.48.139
[servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/home/amitabh/devops-key
ansible_python_interpreter=/usr/bin/python3
```
---
### **Resulting Directory Structure**
```bash
inventories
├── dev
├── prod
└── stg
```
---
# 6\. Creating playbook for installing Nginx on all servers
### **Step 1: Navigate to the Ansible Directory**
If you're not already in the **Ansible** directory, navigate to it first:
```bash
cd ../ansible
```
---
### **Step 2: Create the** `playbooks` Directory
Create the `playbooks` directory inside the **Ansible** directory:
```bash
mkdir playbooks
```
---
### **Step 3: Navigate to the** `playbooks` Directory
Now, navigate into the `playbooks` directory:
```bash
cd playbooks
```
---
### **Step 4: Create the** `install_nginx_playbook.yml` File
Create the `install_nginx_playbook.yml` file with the following content to install **Nginx** and render a webpage using the `nginx-role`:
```yaml
---
- name: Install Nginx and render a webpage to it
hosts: servers
become: yes
roles:
- nginx-role
```
---
### **Step 5: Verify the Directory Structure**
After completing the above steps, your **Ansible** directory structure should look like this:
```bash
ansible
├── inventories
│ ├── dev
│ ├── prod
│ └── stg
├── playbooks
│ └── install_nginx_playbook.yml
```
---
# 7\. Now initializing Roles for nginx named nginx-role from ansible galaxy
Here are the steps to initialize the `nginx-role` using **Ansible Galaxy**, which will generate the necessary folder structure for managing all tasks, files, handlers, templates, and variables related to the Nginx role.
---
### **Step 1: Navigate to the** `playbooks` Directory
If you're not already in the `playbooks` directory, navigate to it:
```bash
cd ansible/playbooks
```
---
### **Step 2: Initialize the** `nginx-role` Using Ansible Galaxy
Now, use the `ansible-galaxy` command to initialize the `nginx-role`:
```bash
ansible-galaxy role init nginx-role
```
This will create the following directory structure within the `nginx-role` folder:
```bash
nginx-role
├── README.md
├── defaults
│ └── main.yml
├── files
│ └── index.html
├── handlers
│ └── main.yml
├── meta
│ └── main.yml
├── tasks
│ └── main.yml
├── templates
├── tests
│ ├── inventory
│ └── test.yml
└── vars
└── main.yml
```
---
### **Step 3: Add Custom Tasks and Files to Your** `nginx-role`
Now that your role structure is ready, you can add your custom **tasks** and **files**.
#### **3.1: Add** `tasks/main.yml`
Create a `tasks/main.yml` file under the `nginx-role/tasks/` directory. This file will contain all the steps to install, configure, and manage the Nginx service. Here's the content for your `tasks/main.yml`:
```yaml
---
# tasks file for nginx-role
- name: Install nginx
apt:
name: nginx
state: latest
- name: Enable nginx
service:
name: nginx
enabled: yes
- name: Deploy webpage
copy:
src: index.html
dest: /var/www/html
```
This will ensure that:
1. **Nginx** is installed with the latest version.
2. **Nginx** service is enabled and starts automatically.
3. The `index.html` file is copied to the `/var/www/html` directory, which is where the default Nginx webpage is served from.
---
#### **3.2: Add a Custom** `index.html` File
You can add an `index.html` file under the `nginx-role/files/` directory. This file can be customized as per your needs. Here's a simplified version of the `index.html` file you provided, with basic content:
```html
Amitabh's DevOps Journey
```
> **Note**: You can replace this HTML content with your own custom webpage content as needed. The goal here is to serve a simple webpage as part of the Nginx configuration.
---
# 8\. To add the `update_inventories.sh` script to your Ansible directory and integrate it with your existing setup, follow these steps:
### **Step 1: Create the** `update_inventories.sh` Script
In your `ansible` directory, create a new file named `update_inventories.sh` with the following content. This script will dynamically update the inventory files for **dev**, **stg**, and **prod** environments based on the IPs fetched from the Terraform outputs.
```bash
#!/bin/bash
# Paths and Variables
TERRAFORM_OUTPUT_DIR="/mnt/c/DevOps-learning/Train-With-Shubham/Terraform-ansible-project/terraform" # Replace with the actual Terraform directory path
ANSIBLE_INVENTORY_DIR="/mnt/c/DevOps-learning/Train-With-Shubham/Terraform-ansible-project/ansible/inventories"
# Navigate to the Terraform directory
cd "$TERRAFORM_OUTPUT_DIR" || { echo "Terraform directory not found"; exit 1; }
# Fetch IPs from Terraform outputs
DEV_IPS=$(terraform output -json dev_infra_instance_public_ips | jq -r '.[]')
STG_IPS=$(terraform output -json stg_infra_instance_public_ips | jq -r '.[]')
PROD_IPS=$(terraform output -json prod_infra_instance_public_ips | jq -r '.[]')
# Function to update inventory file
update_inventory_file() {
local ips="$1"
local inventory_file="$2"
local env="$3"
# Create or clear the inventory file
> "$inventory_file"
# Write the inventory header
echo "[servers]" >> "$inventory_file"
# Add dynamic hosts based on IPs
local count=1
for ip in $ips; do
echo "server${count} ansible_host=$ip" >> "$inventory_file"
count=$((count + 1))
done
# Add common variables
echo "" >> "$inventory_file"
echo "[servers:vars]" >> "$inventory_file"
echo "ansible_user=ubuntu" >> "$inventory_file"
echo "ansible_ssh_private_key_file=/home/amitabh/devops-key" >> "$inventory_file"
echo "ansible_python_interpreter=/usr/bin/python3" >> "$inventory_file"
echo "Updated $env inventory: $inventory_file"
}
# Update each inventory file
update_inventory_file "$DEV_IPS" "$ANSIBLE_INVENTORY_DIR/dev" "dev"
update_inventory_file "$STG_IPS" "$ANSIBLE_INVENTORY_DIR/stg" "stg"
update_inventory_file "$PROD_IPS" "$ANSIBLE_INVENTORY_DIR/prod" "prod"
echo "All inventory files updated successfully!"
```
This script will:
1. Navigate to the **Terraform** directory and fetch the public IPs of the instances for **dev**, **stg**, and **prod** environments.
2. Dynamically generate or update the corresponding **inventory files** in the `ansible/inventories` directory.
3. Add **common variables** for all servers in each environment's inventory file.
---
### **Step 2: Verify the Directory Structure**
After adding the script, your `ansible` directory should look like this:
```bash
ansible
├── inventories
│ ├── dev
│ ├── prod
│ └── stg
├── playbooks
│ ├── install_nginx_playbook.yml
│ └── nginx-role
│ ├── README.md
│ ├── defaults
│ │ └── main.yml
│ ├── files
│ │ └── index.html
│ ├── handlers
│ │ └── main.yml
│ ├── meta
│ │ └── main.yml
│ ├── tasks
│ │ └── main.yml
│ ├── templates
│ ├── tests
│ │ ├── inventory
│ │ └── test.yml
│ └── vars
│ └── main.yml
├── update_inventories.sh
```
---
### **Step 3: Make the Script Executable**
Before running the `update_inventories.sh` script, ensure that it is executable. You can do this by running the following command:
```bash
chmod +x update_inventories.sh
```
---
### **Step 4: Run the Script**
You can now execute the script to update the inventory files with the IPs fetched from Terraform:
```bash
./update_inventories.sh
```
---
### **Step 5: Verify the Inventory Files**
After running the script, check the `inventories` directory. The `dev`, `stg`, and `prod` inventory files should now be updated with the IPs of your servers and the necessary variables.
Example contents of the `dev` inventory file:
```bash
[servers]
server1 ansible_host=192.168.1.10
server2 ansible_host=192.168.1.11
[servers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=/home/amitabh/devops-key
ansible_python_interpreter=/usr/bin/python3
```
Repeat this process for **stg** and **prod** environments as well.
---
### **Step 6: Use the Updated Inventory in Playbooks**
Now that your inventory files are updated, you can reference them in your **Ansible playbooks** by using the `-i` option:
1. For **dev** inventory :
```bash
ansible-playbook -i inventories/dev install_nginx_playbook.yml
```
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1733753368597/2d2fa248-99b2-41e1-9293-9f4473f8c01f.png align="center")
2. For **stg** inventory :
```bash
ansible-playbook -i inventories/stg install_nginx_playbook.yml
```
3. For **prod** inventory
```bash
ansible-playbook -i inventories/prod install_nginx_playbook.yml
```
This will execute the playbook using the updated **all(dev,stg,prod)** inventory.
---
### **Step 7: Varify the all servers whether html page is visible or not (for all inventory like : dev,stg,prod):**
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1733748227873/2b07726b-52b7-4116-a160-1f7d6ae74ca4.png align="center")
---
# 9\. Final Directory structure for this project
```css
.
├── README.md
├── ansible
│ ├── inventories
│ │ ├── dev
│ │ ├── prod
│ │ └── stg
│ ├── playbooks
│ │ ├── install_nginx_playbook.yml
│ │ └── nginx-role
│ │ ├── README.md
│ │ ├── defaults
│ │ │ └── main.yml
│ │ ├── files
│ │ │ └── index.html
│ │ ├── handlers
│ │ │ └── main.yml
│ │ ├── meta
│ │ │ └── main.yml
│ │ ├── tasks
│ │ │ └── main.yml
│ │ ├── templates
│ │ ├── tests
│ │ │ ├── inventory
│ │ │ └── test.yml
│ │ └── vars
│ │ └── main.yml
│ └── update_inventories.sh
└── terraform
├── infra
│ ├── bucket.tf
│ ├── dynamodb.tf
│ ├── ec2.tf
│ ├── output.tf
│ └── variable.tf
├── main.tf
├── providers.tf
├── terraform.tf
├── terraform.tfstate
└── terraform.tfstate.backup
```
---
# 10\. **Infrastructure Destroy**
After successfully implementing and managing your infrastructure across multiple environments with Terraform and Ansible, it's time to clean up and destroy all the resources that were provisioned. This step ensures that no resources are left running, which helps avoid unnecessary costs.
To destroy the infrastructure, follow these simple steps:
1. **Navigate to the Terraform Directory:** Go to the directory where your Terraform configuration files are located. This is typically where your [`main.tf`](http://main.tf) file and other Terraform scripts are present.
```bash
cd /path/to/terraform/directory
```
2. **Run Terraform Destroy:** Execute the following command to destroy all the resources that were created by Terraform. The `--auto-approve` flag ensures that you won’t be prompted to confirm the destruction.
```bash
terraform destroy --auto-approve
```
This command will:
* Destroy all EC2 instances
* Delete all S3 buckets
* Remove any databases or other resources provisioned during the setup
Once the command finishes executing, your infrastructure will be completely torn down, and you will have successfully cleaned up all resources.
This is the final step to ensure that you have a well-managed infrastructure setup that can be recreated anytime using Terraform and Ansible.
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1733753070351/8856d7d7-2a1b-465b-8344-decddb141223.png align="center")
---
**Note:** Be cautious when running `terraform destroy` as it will remove all resources, and data in your infrastructure will be lost. Always ensure that you’ve backed up any important data before performing the destruction.
---
### **Conclusion of the Project**
Congratulations on successfully implementing and managing a multi-environment infrastructure with Terraform and Ansible! Here's a quick recap of what you've achieved:
1. **Infrastructure Setup with Terraform:**
* You began by defining your infrastructure using Terraform, which included provisioning EC2 instances, S3 buckets, and databases across multiple environments: development, staging, and production.
* You followed best practices in managing these resources using Terraform's modular approach and state management.
2. **Automating Server Configuration with Ansible:**
* After setting up your infrastructure, you leveraged Ansible for configuration management. You initialized and structured an Nginx role using Ansible Galaxy, allowing you to efficiently manage the installation and configuration of Nginx across all environments.
* You also created dynamic inventories for each environment, making it easy to manage server configurations in a scalable way.
3. **Environment-Specific Configurations:**
* By dynamically fetching IPs from Terraform outputs and updating your Ansible inventories, you ensured that each environment had its own specific configuration, enabling streamlined management of resources across dev, staging, and production environments.
4. **Simplified Infrastructure Management:**
* With Ansible, you automated the installation, configuration, and updates of necessary software (like Nginx), reducing manual effort and human error.
* The use of Terraform and Ansible together allowed you to achieve both infrastructure provisioning and configuration management in a clean, reproducible, and automated way.
5. **Final Cleanup:**
* As a final step, you executed the `terraform destroy` command to tear down the infrastructure that was created. This ensured that you could clean up all resources, including instances, databases, and storage, once the project was completed.
---
This project has provided you with hands-on experience in managing infrastructure and configurations for multiple environments using industry-standard tools like Terraform and Ansible. You have successfully automated your infrastructure management, from provisioning to configuration, across different environments.
You can now apply these skills to any real-world scenario, ensuring that infrastructure is managed efficiently, securely, and consistently across any environment.