Ansible Automation For Beginners to Advance – Step by Step

Have You interested in automation using Ansible?

But don’t know where from You start?�

Well, this Ansiblecourse will learn you, how you can Know Automation within few months.This is a professional  Ansiblevideo course, created by an Automation Experts having 5+ years of experience in this field.This course starts with the architecture of Ansible. Ansible automation engine that’s automated cloud Multi-tier deployments provisioning configuration management application deployment intra service orchestration and many other IT needs.

Radically simple IT automation about practical, abstracts items.Playbook in Ansible is written in YAML format, commonly used for configuration files.Ansible defines a rich set up of variables, individual for each system.The  Ansiblecourse divided into six sections, starting with initial installation of Ansible and foundation concepts.

What is Ansible?

Ansible is an open-source IT automation platform.It can remove a huge drudgery  from your work life.It also  improve the scalability, consistency, and reliability of the IT environment. In this course, we’ll start to explore how to automate all the repetitive system administration tasks using Ansible.

Ansible used for many applications where data is being stored. Most of them which are defined previously to enable more flexibility in Ansibleplaybooks and roles. Apart from this uses values, Access various information like the hostname of the system and replace certain strings in templates with specific values. There is naming variable. Variable Names should be letters, numbers or underscores.

Mastering Ansible is a step by step journey of learning Ansible for configuration management and orchestration.Interesting Ansible course is designed by a journey through configuring a practical application stack from the ground.In addition the concepts of configuration management of Ansible we spent the time to build some tools to maintain troubleshoot our application.

The Ansible course is designed mainly for the introduction of Ansible but at the same time its a guide for Engineers interested in Ansible configuration management and orchestration, IT automation, infrastructure as code DevOps principles.Here is no required for previous programming and automation experience.

What is in this Ansible course?

The Ansible course introduces a beginner to basic fundamental of Ansible that you can easily do hands-on exercises right in the browser.The course provides basic use cases of Ansible followed by the introduction of an Ansible inventory, Configuration Management, patterns,

Playbooks, Modules, Conditionals, Loops and Roles, Ansible With Vagrant.

Let’s have a quick look what you are going to discuss throughout the whole course!

Ansible Inventory: At the same time Ansible works against multiple systems in your infrastructure. It does this by selecting portions of systems listed in Ansible inventory.

Ansible Configuration Management: Ansible is the simplest solution for configuration management.The descriptive data (both human readable and machine parsable) ensuring everyone and able to understand the meaning of each Configuration task.configuration management designed for consistent secure and highly reliable with the extremely low learning curve for Administrators, developers and IT manager.

Ansible Playbooks: Playbooks are Ansible’s configuration, deployment, and orchestration language. Many Ansible’s application which defined previously to enable more flexibility in playbooks.

Ansible With Vagrant: Ansible With Vagrant allows to provides the guest using Ansible Playbooks by executing Ansible Playbook from Vagrant host.General Ansible concepts like playbook or inventory are shortly explained in the introduction of Ansible With Vagrant.

Ansible Modules:The section discuss how to develop, debug, review and test modules. A number of Modules in Ansible ship called The Modules Library which can be executed mainly on a remote host or through playbooks.

What is so special in this Ansible course?

The course is very simple, awesome, easy to understand, agentless, parallel execution, automatic reporting easy to use and at the same time it is a time saver, In a few months you know the course and become more productive in your own goal. This is the one and the only Ansible course that provisions coding exercise were you can practice Ansible Playbook right in your browser.

How does Ansible work?

Ansible connecting your nodes and pushing out small programs.Ansible works very simple and different way of setting up the Architecture, SSH keys and their roles and Managing Inventory.

How does Ansible Playbook work?

Ansible playbook works as an Ansible configuration, deployment, and orchestration language.The playbook can finely orchestrate multiple slices of your infrastructure topology with very detail control over how many machines to tackle at the same time.

How does Ansible Tower work?

Ansible tower works as a scale IT automation, manage complex deployments and speed productivity.The Ansible tower allows us to easily streamline the delivery of applications and service to both OpenStack and Amazon clouds in a cost-effective simple and secure manner.

How does Ansible Vault work?

Ansible Vault is a feature of Ansible that keeps sensitive data such as password or keys in encrypted files rather than a plaintext in playbook or role.Ansible Vault encrypts anything inside a YAML file, with a password in your own choice.The vault file can distribute or place in source control.

What are the steps to start Ansible?

At first, Ansible installs your local machine.In order for Ansible to connect your VPS, you need to specify its IP address within Ansible host file.Test out your configuration by pinging your VPS for

If you are interested you can go through the article bellow:-

……………………………………………………………………………………………………………………………….

In a previous guide, we discussed how to install the Ansible software and learn basic commands. In this guide, we will discuss Ansible playbooks, which are Ansible’s way of creating automated scripts to configure client computers.

We will assume that you have a configured Ansible server and a few clients, just as we left off in the last tutorial. In our guide, the server is a Ubuntu 12.04 machine, and the clients that we are going to be configuring are also Ubuntu 12.04 machines, for ease of explanation.

What are Ansible Playbooks?

Ansible playbooks are a way to send commands to remote computers in a scripted way. Instead of using Ansible commands individually to remotely configure computers from the command line, you can configure entire complex environments by passing a script to one or more systems.

Ansible playbooks are written in the YAML data serialization format. If you don’t know what a data serialization format is, think of it as a way to translate a programmatic data structure (lists, arrays, dictionaries, etc) into a format that can be easily stored to disk. The file can then be used to recreate the structure at a later point. JSON is another popular data serialization format, but YAML is much easier to read.

Each playbook contains one or more plays, which map hosts to a certain function. Ansible does this through something called tasks, which are basically module calls.

Exploring a Basic Playbook

Let’s look at a basic playbook:

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

  handlers:
    – name: start nginx
      service: name=nginx state=started

Let’s break this down in sections so we can understand how these files are built and what each piece means.

The file starts with:

—

This is a requirement for YAML to interpret the file as a proper document. YAML allows multiple “documents” to exist in one file, each separated by —, but Ansible only wants one per file, so this should only be present at the top of the file.

YAML is very sensitive to white-space, and uses that to group different pieces of information together. You should use only spaces and not tabs and you must use consistent spacing for your file to be read correctly. Items at the same level of indentation are considered sibling elements.

Items that begin with a – are considered list items. Items that have the format of key: value operate as hashes or dictionaries. That’s pretty much all there is to basic YAML.

YAML documents basically define a hierarchical tree structure with the containing elements further to the left.

On the second line, we have this:

—
– hosts: droplets
This is a list item in YAML as we learned above, but since it is at the left-most level, it is also an Ansible “play”. Plays are basically groups of tasks that are performed on a certain set of hosts to allow them to fulfill the function you want to assign to them. Each play must specify a host or group of hosts, as we do here.

Next, we have a set of tasks:

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

At the top level, we have “tasks:” at the same level as “hosts:”. This contains a list (because it starts with a “-“) which contains key-value pairs.

The first one, “name”, is more of a description than a name. You can call this whatever you would like.

The next key is “apt”. This is a reference to an Ansible module, just like when we use the ansible command and type something like:

ansible -m apt -a ‘whatever’ all

This module allows us to specify a package and the state that it should be in, which is “installed” in our case. The update-cache=true part tells our remote machine to update its package cache (apt-get update) prior to installing the software.

The “notify” item contains a list with one item, which is called “start nginx”. This is not an internal Ansible command, it is a reference to a handler, which can perform certain functions when it is called from within a task. We will define the “start nginx” handler below.

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

  handlers:
    – name: start nginx
      service: name=nginx state=started

The “handlers” section exists at the same level as the “hosts” and “tasks”. Handlers are just like tasks, but they only run when they have been told by a task that changes have occurred on the client system.

For instance, we have a handler here that starts the Nginx service after the package is installed. The handler is not called unless the “Installs nginx web server” task results in changes to the system, meaning that the package had to be installed and wasn’t already there.

We can save this playbook into a file called something like “nginx.yml”.

Just for some context, if you were to write this same file in JSON, it might look something like this:

[
    {
        “hosts”: “droplets”,
        “tasks”: [
            {
                “name”: “Installs nginx web server”,
                “apt”: “pkg=nginx state=installed update_cache=true”,
                “notify”: [
                    “start nginx”
                ]
            }
        ],
        “handlers”: [
            {
                “name”: “start nginx”,
                “service”: “name=nginx state=started”
            }
        ]
    }
]

As you can see, YAML is much more compact and most people would say more readable.

Running an Ansible Playbook

Once you have a playbook built, you can call it easily using this format:

ansible-playbook playbook.yml

For instance, if we wanted to install and start up Nginx on all of our droplets, we could issue this command:

ansible-playbook nginx.yml

Since the playbook itself specifies the hosts that it should run against (namely, the “droplets” group we created in the last tutorial), we do not have to specify a host to run against.

However, if we would like to filter the host list to only apply to one of those hosts, we can add a flag to specify a subset of the hosts in the file:

ansible-playbook -l host_subset playbook.yml

So if we only wanted to install and run Nginx on our “host3”, we could type this:

ansible-playbook -l host3 nginx.yml

Adding Features to the Ansible Playbook

Right now our playbook looks like this:

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

  handlers:
    – name: start nginx
      service: name=nginx state=started

It is simple and it works, but all it is doing is installing a piece of software and starting it. That’s not very beneficial by itself.

We can start to expand the functionality by adding tasks to our playbook.

Add a Default Index File

We can tell it to transfer a file from our Ansible server onto the host by adding some lines like this:

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

    – name: Upload default index.html for host
      copy: src=static_files/index.html dest=/usr/share/nginx/www/ mode=0644

  handlers:
    – name: start nginx
      service: name=nginx state=started

We can then make a directory called static_files in our current directory and place an index.html file inside.

mkdir static_files
nano static_files/index.html

Inside of this file, let’s just create a basic html structure:

<html>
  <head>
    <title>This is a sample page</title>
  </head>
  <body>
    <h1>Here is a heading!</h1>
    <p>Here is a regular paragraph.  Wow!</p>
  </body>
</html>

Save and close the file.

Now, when we re-run the Ansible playbook, Ansible will check each task. It will see that Nginx is already installed on the host, so it will leave it be. It will see the new task section and replace the default index.html file with the one from our server.

Registering Results

When you are installing and configuring services manually, it is almost always necessary to know whether your actions were successful or not. We can cook this functionality into our playbooks by using “register”.

For each task, we can optionally register its result (failure or success) in a variable that we can check later on.

When using this functionality, we also have to tell Ansible to ignore errors for that task, since normally it aborts the Ansible playbook execution for that host if any trouble happens.

So, if we want to check whether a task has failed or not to decide on subsequent steps, we can use the register functionality.

For instance, we could tell our Ansible playbook to upload an index.php file if it exists. If that task fails, we could instead try to upload an index.html file. We will check for the failure condition in the other task because we only want to upload the HTML file if the PHP file fails:

—
– hosts: droplets
  tasks:
    – name: Installs nginx web server
      apt: pkg=nginx state=installed update_cache=true
      notify:
        – start nginx

    – name: Upload default index.php for host
      copy: src=static_files/index.php dest=/usr/share/nginx/www/ mode=0644
      register: php
      ignore_errors: True

    – name: Remove index.html for host
      command: rm /usr/share/nginx/www/index.html
      when: php|success

    – name: Upload default index.html for host
      copy: src=static_files/index.html dest=/usr/share/nginx/www/ mode=0644
      when: php|failed

  handlers:
    – name: start nginx
      service: name=nginx state=started

Note: We have not configured our host to handle PHP files at this time, so even if you did upload a PHP file, it would not be processed correctly.

This new version tries to upload a PHP index file to the host. It registers the success of the operation into a variable called “php”.

If this operation was successful, the task to remove the index.html file is run next.

If the operation failed, the index.html file is uploaded instead.

Conclusion

Now, you should have a good handle on how to automate complex tasks using Ansible. This is a basic example of how you can begin to build your configuration library in Ansible .

Combining host and group definitions as we learned about in the first tutorial, and using available variables to fill in information, we can begin to put together complex computer systems that interact with each other. In a future article, we will discuss how to implement variables into our Ansible playbooks and create roles to help manage complex tasks.

Rating Distribution

• 1 stars: 61 votes
• 2 stars: 40 votes
• 3 stars: 82 votes
• 4 stars: 106 votes
• 5 stars: 282 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!