Intermediate Ansible: Beyond the Basics

Building on our previous tutorial, we’ll explore intermediate Ansible concepts by creating a more complex deployment: a load-balanced web application with customizable configurations.

Prerequisites

• Basic Ansible knowledge
• Understanding of YAML syntax
• Familiarity with web servers and load balancing
• Multiple target servers for testing

Concepts Covered

1. Roles
2. Variables
3. Templates
4. Handlers
5. Conditionals
6. Tags

Project Structure

webapp-deployment/
├── inventory/
│   ├── production
│   └── staging
├── group_vars/
│   ├── all.yml
│   ├── webservers.yml
│   └── loadbalancers.yml
├── roles/
│   ├── common/
│   ├── webapp/
│   └── loadbalancer/
└── site.yml

Working Example: Load Balanced Web App

Let’s create a deployment that:

• Sets up multiple web servers
• Configures Nginx as a load balancer
• Uses templates for configuration
• Implements handlers for service restarts

1. Inventory Setup

Create inventory/staging:

[webservers]
web1 ansible_host=192.168.1.11
web2 ansible_host=192.168.1.12

[loadbalancers]
lb1 ansible_host=192.168.1.10

[all:vars]
ansible_python_interpreter=/usr/bin/python3

2. Group Variables

Create group_vars/all.yml:

---
app_name: mywebapp
app_version: "1.0.0"
app_port: 8080
domain: example.com

Create group_vars/webservers.yml:

---
app_user: webapp
app_path: /var/www/
app_config_template: webapp.conf.j2

3. Role Structure

Create the webapp role:

ansible-galaxy init roles/webapp

4. Role Implementation

Create roles/webapp/tasks/main.yml:

---
- name: Ensure app user exists
  user:
    name: ""
    shell: /bin/bash
    createhome: yes

- name: Create application directories
  file:
    path: ""
    state: directory
    owner: ""
    mode: '0755'
  with_items:
    - ""
    - "/config"

- name: Copy application configuration
  template:
    src: ""
    dest: "/config/app.conf"
    owner: ""
    mode: '0644'
  notify: restart webapp

- name: Deploy application files
  copy:
    src: files/webapp/
    dest: ""
    owner: ""
    mode: '0644'
  notify: restart webapp

Create roles/webapp/handlers/main.yml:

---
- name: restart webapp
  service:
    name: ""
    state: restarted

5. Templates

Create roles/webapp/templates/webapp.conf.j2:

# Application Configuration
app_name = 
version = 
port = 

# Environment specific settings

debug = true
log_level = DEBUG


# Dynamic server list
servers = [

]

6. Main Playbook

Create site.yml:

---
- name: Configure common settings
  hosts: all
  become: yes
  roles:
    - common

- name: Deploy web application
  hosts: webservers
  become: yes
  roles:
    - webapp
  tags:
    - webapp
    - deploy

- name: Configure load balancer
  hosts: loadbalancers
  become: yes
  roles:
    - loadbalancer
  tags:
    - loadbalancer

Running the Deployment

1. Test syntax:

   ansible-playbook -i inventory/staging site.yml --syntax-check
   

2. Dry run:

   ansible-playbook -i inventory/staging site.yml --check
   

3. Deploy to staging:

   ansible-playbook -i inventory/staging site.yml
   

4. Deploy specific roles:

   ansible-playbook -i inventory/staging site.yml --tags webapp
   

Advanced Features Used

1. Templates with Conditionals: ```jinja

# Development settings

2. **Dynamic Inventories**:
```yaml

1. Handlers for Service Management:

   handlers:
     - name: restart webapp
    service:
      name: ""
      state: restarted
   

Best Practices

1. Role Organization:
   • Keep roles focused and single-purpose
   • Use dependencies for shared functionality
   • Document role variables
2. Variable Management:
   • Use group_vars for common settings
   • Override variables at multiple levels
   • Use vault for sensitive data
3. Template Usage:
   • Keep templates simple
   • Use comments for clarity
   • Test template rendering separately

Debugging Tips

1. Check template rendering:

   ansible-playbook site.yml --check -vv
   

2. Debug variables:

   - debug:
    var: some_variable
   

3. Use tags for targeted runs:

   ansible-playbook site.yml --tags "config,deploy"
   

Conclusion

You’ve now learned how to create a modular, reusable Ansible deployment using roles, variables, and templates. This foundation will help you tackle more complex automation scenarios.

Stay tuned for our advanced Ansible tutorial where we’ll explore custom modules, dynamic inventories, and complex orchestration patterns.