{"id":11794,"date":"2019-03-17T10:36:23","date_gmt":"2019-03-17T10:36:23","guid":{"rendered":"http:\/\/www.appservgrid.com\/paw92\/?p=11794"},"modified":"2019-03-17T10:36:23","modified_gmt":"2019-03-17T10:36:23","slug":"how-to-install-and-configure-ansible-automation-tool-for-it-management","status":"publish","type":"post","link":"https:\/\/www.appservgrid.com\/paw92\/index.php\/2019\/03\/17\/how-to-install-and-configure-ansible-automation-tool-for-it-management\/","title":{"rendered":"How to Install and Configure \u2018Ansible\u2019 Automation Tool for IT Management"},"content":{"rendered":"

Ansible<\/b>\u00a0is an open source, powerful automation software for configuring, managing and deploying software applications on the nodes without any downtime just by using SSH. Today, most of the IT Automation tools runs as a agent in remote host, but ansible just need a SSH connection and Python (2.4 or later) to be installed on the remote nodes to perform it\u2019s action.<\/p>\n

\n

\"Install<\/a><\/p>\n

Install Ansible in Linux<\/p>\n<\/div>\n

How Ansible Works?<\/h4>\n

There are many similar automation tools available like Puppet, Capistrano, Chef, Salt, Space Walk etc, but Ansible categorize into two types of server: controlling machines and nodes.<\/p>\n

The controlling machine, where Ansible is installed and Nodes are managed by this controlling machine over SSH. The location of nodes are specified by controlling machine through its inventory.<\/p>\n

The controlling machine (Ansible) deploys modules to nodes using SSH protocol and these modules are stored temporarily on remote nodes and communicate with the Ansible machine through a JSON connection over the standard output.<\/p>\n

Ansible is agent-less, that means no need of any agent installation on remote nodes, so it means there are no any background daemons or programs are executing for Ansible, when it\u2019s not managing any nodes.<\/center>Ansible can handle 100\u2019s of nodes from a single system over SSH connection and the entire operation can be handled and executed by one single command \u2018ansible\u2019. But, in some cases, where you required to execute multiple commands for a deployment, here we can build playbooks.<\/p>\n

Playbooks are bunch of commands which can perform multiple tasks and each playbooks are in YAML file format.<\/p>\n

What\u2019s the Use of Ansible<\/h4>\n

Ansible<\/strong>\u00a0can be used in IT infrastructure to manage and deploy software applications to remote nodes. For example, let\u2019s say you need to deploy a single software or multiple software to 100\u2019s of nodes by a single command, here ansible comes into picture, with the help of Ansible you can deploy as many as applications to many nodes with one single command, but you must have a little programming knowledge for understanding the ansible scripts.<\/p>\n

We\u2019ve compiled a series on Ansible, title \u2018Preparation for the Deployment of your IT Infrastructure with Ansible IT Automation Tool<\/strong>\u2018, through parts 1-4 and covers the following topics.<\/p>\n

Part 1<\/b>:\u00a0How to Install and Configure Ansible for IT Management in Linux<\/b><\/div>\n
Part 2<\/b>:\u00a0How to Use Anisble Playbooks to Automate Complex Tasks on Multiple Remote Servers<\/a><\/div>\n
Part 3<\/b>:\u00a0How to Automate Simultaneous WordPress Deployments in Multiple Linux Servers Using Ansible<\/a><\/div>\n
Part 4<\/b>:\u00a0Managing Encrypted YAMAL data with Ansible-Vault<\/b><\/div>\n

In this article, we will show you how to install \u2018Ansible\u2019 on RHEL\/CentOS 7\/6, Fedora 21-19, Ubuntu 14.10-13.04 and Debian 7\/6 systems and also we will go through some basics on how how to manage a server by installing packages, applying updates and much more from basic to pro.<\/p>\n

Prerequisites<\/h4>\n
    \n
  1. Operating System<\/b>: RHEL\/CentOS\/Fedora and Ubuntu\/Debian\/Linux Mint<\/li>\n
  2. Jinja2<\/b>: A modern, fast and easy to use stand-alone template engine for Python.<\/li>\n
  3. PyYAML<\/b>: A YAML parser and emitter for the Python programming language.<\/li>\n
  4. parmiko<\/b>: A native Python SSHv2 channel library.<\/li>\n
  5. httplib2<\/b>: A comprehensive HTTP client library.<\/li>\n
  6. sshpass<\/b>: A non-interactive ssh password authentication.<\/li>\n<\/ol>\n

    My Environment Setup<\/h4>\n

    Controlling Machine \u2013 Ansible<\/h5>\n
    Operating System :\tLinux Mint 17.1 Rebecca\r\nIP Address\t :\t192.168.0.254\r\nHost-name\t :\ttecmint.instrcutor.com\r\nUser\t\t :\ttecmint\r\n<\/pre>\n
    Remote Nodes<\/h5>\n
    Node 1: 192.168.0.112\r\nNode 2: 192.168.0.113\r\nNode 3: 192.168.0.114\r\n<\/pre>\n
    Step 1: Installing Controlling Machine \u2013 Ansible<\/h3>\n
    1.<\/strong>\u00a0Before installing \u2018Ansible<\/strong>\u2018 on the server, let\u2019s first verify the details of the server like hostname and IP Address. Login into server as a root user and execute the below command to confirm system settings that we\u2019re going to use for this setup.<\/p>\n
    # sudo ifconfig | grep inet\r\n<\/pre>\n
    \n
    \"Verify<\/a><\/p>\n
    Verify System Details<\/p>\n<\/div>\n
    2.<\/strong>\u00a0Once you confirm your system settings, it\u2019s time to install \u2018Ansible\u2019 software on the system.<\/p>\n
    On Ubuntu\/Debian\/Linux Mint<\/h5>\n
    Here we are going to use official Ansible PPA repository on the system, just run the below commands to add the repository.<\/p>\n
    $ sudo apt-add-repository ppa:ansible\/ansible -y\r\n$ sudo apt-get update && sudo apt-get install ansible -y\r\n<\/pre>\n
    \n
    \"Add<\/a><\/p>\n
    Add Ansible PPA<\/p>\n<\/div>\n
    \n
    \"Install<\/a><\/p>\n
    Install Ansible in Ubuntu<\/p>\n<\/div>\n
    On RHEL\/CentOS\/Fedora<\/h5>\n
    Unfortunately, there are no official Ansible repository for RedHat based clones, but we can install Ansible by enabling epel repository under RHEL\/CentOS 6, 7 and currently supported fedora distributions.<\/p>\n
    Fedora users can directly install Ansible through default repository, but if you are using RHEL\/CentOS 6, 7, you have to\u00a0enable EPEL repo<\/a>.<\/p>\n
    After configuring epel repository, you can install Ansible using following command.<\/p>\n
    $ sudo yum install ansible -y\r\n<\/pre>\n
    After installed successfully, you can verify the version by executing below command.<\/p>\n
    # ansible --version\r\n<\/pre>\n
    \n
    \"Verify<\/a><\/p>\n
    Verify Ansible Version<\/p>\n<\/div>\n
    Step 2: Preparing SSH Keys to Remote Hosts<\/h3>\n
    4.<\/strong>\u00a0To perform any deployment or management from the localhost to remote host first we need to create and copy the ssh keys to the remote host. In every remote host there will be a user account\u00a0tecmint<\/strong>\u00a0(in your case may be different user).<\/p>\n
    First let we create a SSH key using below command and copy the key to remote hosts.<\/p>\n
    # ssh-keygen -t rsa -b 4096 -C \"admin@tecmintlocal.com\"\r\n<\/pre>\n
    \n
    \"Create<\/a><\/p>\n
    Create SSH Key<\/p>\n<\/div>\n
    5.<\/strong>\u00a0After creating SSH Key successfully, now copy the created key to all three remote server\u2019s.<\/p>\n
    # ssh-copy-id tecmint@192.168.0.112\r\n# ssh-copy-id tecmint@192.168.0.113\r\n# ssh-copy-id tecmint@192.168.0.114\r\n<\/pre>\n
    \n
    \"Copy<\/a><\/p>\n
    Copy SSH Key Remote Server<\/p>\n<\/div>\n
    \n
    \"Copy<\/a><\/p>\n
    Copy SSH Key Second Remote Host<\/p>\n<\/div>\n
    6.<\/strong>\u00a0After copying all SSH Keys to remote host, now perform a ssh key authentication on all remote hosts to check whether authentication working or not.<\/p>\n
    $ ssh tecmint@192.168.0.112\r\n$ ssh tecmint@192.168.0.113\r\n$ ssh tecmint@192.168.0.114\r\n<\/pre>\n
    \n
    \"SSH<\/a><\/p>\n
    SSH Key Authentication<\/p>\n
     <\/p>\n<\/div>\n
    Step 3: Creating Inventory File for Remote Hosts<\/h3>\n
    Inventory<\/b>\u00a0file, This file hold the host information\u2019s like which host we need to get connect from local to remote. Default inventory file will be under\u00a0\/etc\/ansible\/hosts<\/b>.<\/p>\n
    7.<\/strong>\u00a0Now let\u2019s add these three hosts to inventory file. Open and edit file using your favourite editor, Here I use vim.<\/p>\n
    # sudo vim \/etc\/ansible\/hosts\r\n<\/pre>\n
    Add the following three hosts IP address..<\/p>\n
    [web-servers]\r\n192.168.0.112\r\n192.168.0.113\r\n192.168.0.114\r\n<\/pre>\n
    Note<\/strong>: The \u2018web-servers<\/strong>\u2018 in the brackets indicates as group names, it is used in classifying systems and deciding which systems you are going to controlling at what times and for what reason.<\/p>\n
    \n
    \"Create<\/a><\/p>\n
    Create Ansible Inventory File<\/p>\n
    8.<\/strong>\u00a0Now time to check our all 3 server by just doing a ping from my localhost. To perform the action we need to use the command \u2018ansible<\/b>\u2018 with options \u2018-m<\/strong>\u2018 (module) and \u2018-all<\/strong>\u2018 (group of servers).<\/p>\n
    # ansible -m ping web-servers\r\n\r\nOR\r\n\r\n# ansible -m ping -all\r\n\r\n<\/pre>\n
    \n
    \"Ping<\/a><\/p>\n
    Ping Remote Hosts<\/p>\n<\/div>\n
    In the above example, we\u2019ve used ping module with Ansible command to ping all remote hosts at ones, the same way there are various modules can be used with Ansible, you can find available modules from ansible Official site\u00a0here<\/a>.<\/p>\n
    9.<\/strong>\u00a0Now, here we are using another module called \u2018command<\/strong>\u2018, which is used to execute list of commands (like, df, free, uptim, etc.) on all selected remote hosts at one go, for example watch out few examples shown below.<\/p>\n
    a.<\/strong>\u00a0To check the partitions on all remote hosts<\/p>\n
    # ansible -m command -a \"df -h\" web-servers\r\n<\/pre>\n
    \n
    \"Check<\/a><\/p>\n
    Check Disk Space on all Hosts<\/p>\n<\/div>\n
    b.<\/strong>\u00a0Check memory usage on all remote hosts.<\/p>\n
    # ansible -m command -a \"free -mt\" web-servers\r\n<\/pre>\n
    \n
    \"Check<\/a><\/p>\n
    Check Memory on all Hosts<\/p>\n<\/div>\n
    c.<\/strong>\u00a0Checking Uptime for all 3 servers.<\/p>\n
    # ansible -m command -a \"uptime\" web-servers\r\n<\/pre>\n
    \n
    \"Check<\/a><\/p>\n
    Check uptime on all Hosts<\/p>\n<\/div>\n
    d.<\/strong>\u00a0Check for hostname and Architecture.<\/p>\n
    # ansible -m command -a \"arch\" web-servers\r\n# ansible -m shell -a \"hostname\" web-servers\r\n<\/pre>\n
    \n
    \"Check<\/a><\/p>\n
    Check hostname on all Hosts<\/p>\n<\/div>\n
    e.<\/strong>\u00a0If we need the output to any file we can redirect as below.<\/p>\n
    # ansible -m command -a \"df -h\" web-servers > \/tmp\/df_outpur.txt\r\n<\/pre>\n
    \n
    \"Redirect<\/a><\/p>\n
    Redirect Output to File<\/p>\n<\/div>\n
    Like this way, we can run many shell commands using ansible as what we have run the above steps.<\/p>\n
    Conclusion<\/h3>\n
    Okay, We can see how to in next article.<\/p>\n
    Ansible is a Powerful IT automation tool which is must every sysadmins for deploying applications and managing server\u2019s at one go. Among any other automation tool such as puppet, Capistrano, salt, Ansible is quit very interesting and very easy to setup for production environment. Capistrano oh no i feel headache please leave me alone :p this what i used to say.<\/p>\n
    Ansible use only SSH as there agent. We don\u2019t have to install and run any agent in the remote servers. Hope this article will be interesting one for you too. In our next article, I will show you how to setup the directory structure for Ansible deployment and creating playbooks and working with it.<\/p>\n
    Till then keep on tracking us to get updated articles and don\u2019t forget to tell us your opinions on the Ansible and also tell us do you use any other automation tool which is more powerful than Ansible\u2026.<\/p>\n
    Reference Links<\/h3>\n
    http:\/\/www.ansible.com\/get-started<\/a>
    \n    http:\/\/docs.ansible.com\/<\/a><\/p>\n
     <\/p>\n<\/div>\n
    In the\u00a0previous article of this Ansible series<\/a>, we explained that Ansible is an agent-less tool that allows you to quickly and efficiently manage multiple machines (also known as nodes \u2013 and perform deployments to them as well) from a single system.<\/p>\n
    \n
    \"Use<\/a><\/p>\n
    Use Ansible Playbooks to Automate Complex Tasks on Linux \u2013 Part 2<\/p>\n<\/div>\n
    After installing the software in the controller machine, creating the\u00a0keys for passwordless login<\/a>\u00a0and copying them to the nodes, it\u2019s time to learn how to optimize the process of managing such remote systems using\u00a0Ansible<\/strong>.<\/p>\n
    Ansible Testing Environment<\/h4>\n
    Throughout this article, as well as the next one, we will use the following test environment. All hosts are\u00a0CentOS 7<\/strong>\u00a0boxes:<\/p>\n
    Controller machine (where Ansible is installed): 192.168.0.19<\/strong>\r\nNode1: 192.168.0.29<\/strong>\r\nNode2: 192.168.0.30<\/strong>\r\n<\/pre>\n
    In addition, please note that both nodes have been added in the webservers section of the local\u00a0\/etc\/ansible\/hosts<\/strong>\u00a0file:<\/p>\n
    \n
    \"Ansible<\/a><\/p>\n
    Ansible Host File<\/p>\n
    That said, let\u2019s get started with the topic at hand.<\/p>\n
    Introducing Ansible Playbooks<\/h3>\n
    As described in the previous guide, you can use the\u00a0ansible<\/strong>\u00a0utility to run commands in remote nodes as follows:<\/p>\n
    # ansible -a \"\/bin\/hostnamectl --static\" webservers\r\n<\/pre>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Run Commands on Remote Linux<\/p>\n<\/div>\n
    In the example above, we ran\u00a0hostnamectl --static<\/code>\u00a0on\u00a0node1<\/strong>\u00a0and\u00a0node2<\/strong>. It doesn\u2019t take long for one to realize that this method of running tasks on remote computers works fine for short commands but can quickly become burdensome or messy for more complex tasks that require further well-structured configuration parameters or interactions with other services<\/p>\n
    For example, setting up and configuring\u00a0WordPress<\/strong>\u00a0on multiple hosts \u2013 which we will cover in the next article of this series). This is where\u00a0Playbooks<\/strong>\u00a0come into scene.<\/p>\n
    Simply put,\u00a0Playbooks<\/strong>\u00a0are plain text files written in the\u00a0YAML<\/strong>\u00a0format, and contain a list with items with one or more key\/value pairs (also known as a \u201chash<\/strong>\u201d or a \u201cdictionary<\/strong>\u201d).<\/p>\n
    Inside each Playbook you will find one or more group of hosts (each one of these groups is also called a\u00a0play<\/strong>) where the desired tasks are to be performed.<\/p>\n
    An example from the official docs will help us to illustrate:<\/p>\n
    1.<\/strong>\u00a0hosts<\/strong>: this is a list of machines (as per\u00a0\/etc\/ansible\/hosts<\/strong>) where the following tasks will be performed.<\/p>\n
    2.<\/strong>\u00a0remote_user<\/strong>: remote account that will be used to perform the tasks.<\/p>\n
    3.<\/strong>\u00a0vars<\/strong>: variables used to modify the behavior of the remote system(s).<\/p>\n
    4.<\/strong>\u00a0tasks are executed in order, one at a time, against all machines that match hosts. Within a play, all hosts are going to get the same task directives.<\/p>\n
    If you need to execute a different set of associated tasks for a specific host, create another play in the current\u00a0Playbook<\/strong>\u00a0(in other words, the purpose of a play is to map a specific selection of hosts to well-defined tasks).<\/p>\n
    In that case, start a new play by adding the hosts directive at the bottom and starting over:<\/p>\n
    ---\r\n- hosts: webservers\r\n  remote_user: root\r\n  vars:\r\n    variable1: value1\r\n    variable2: value2\r\n  remote_user: root\r\n  tasks:\r\n  - name: description for task1\r\n    task1: parameter1=value_for_parameter1 parameter2=value_for_parameter2\r\n  - name: description for task1\r\n    task2: parameter1=value_for_parameter1 parameter2=value_for_parameter2\r\n  handlers:\r\n    - name: description for handler 1\r\n      service: name=name_of_service state=service_status\r\n- hosts: dbservers\r\n  remote_user: root\r\n  vars:\r\n    variable1: value1\r\n    variable2: value2\r\n\u2026\r\n<\/pre>\n
    5.<\/strong>\u00a0handlers are actions that are triggered at the end of the tasks section in each play, and are mostly used to restart services or trigger reboots in the remote systems.<\/p>\n
    # mkdir \/etc\/ansible\/playbooks\r\n<\/pre>\n
    And a file named\u00a0apache.yml<\/strong>\u00a0inside of there with the following contents:<\/p>\n
    ---\r\n- hosts: webservers\r\n  vars:\r\n    http_port: 80\r\n    max_clients: 200\r\n  remote_user: root\r\n  tasks:\r\n  - name: ensure apache is at the latest version\r\n    yum: pkg=httpd state=latest\r\n  - name: replace default index.html file\r\n    copy: src=\/static_files\/index.html dest=\/var\/www\/html\/ mode=0644\r\n    notify:\r\n    - restart apache\r\n  - name: ensure apache is running (and enable it at boot)\r\n    service: name=httpd state=started enabled=yes\r\n  handlers:\r\n    - name: restart apache\r\n      service: name=httpd state=restarted\r\n<\/pre>\n
    Second, create a directory \/static_files:<\/p>\n
    # mkdir \/static_files\r\n<\/pre>\n
    where you will store the custom\u00a0index.html<\/strong>\u00a0file:<\/p>\n
    <!DOCTYPE html>\r\n <html lang=\"en\">\r\n <head>\r\n <meta charset=\"utf-8\"\/>\r\n <\/script>\r\n <\/head>\r\n <body>\r\n <h1>Apache was started in this host via Ansible<\/h1><br>\r\n<h2>Brought to you by Tecmint.com<\/h2>\r\n <\/body>\r\n <\/html>\r\n<\/pre>\n
    That said, now it\u2019s time to use this playbook to perform the tasks mentioned earlier. You will note that Ansible will go through each task by host, one at a time, and will report on the status of such tasks:<\/p>\n
    # ansible-playbook \/etc\/ansible\/playbooks\/apache.yml\r\n<\/pre>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Automate Tasks in Linux<\/p>\n<\/div>\n
    Now let\u2019s see what happens when we open a browser and point it to\u00a0192.168.0.29<\/strong>\u00a0and\u00a0192.168.0.30<\/strong>:<\/p>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Confirm Automated Tasks<\/p>\n<\/div>\n
    Let\u2019s go one step further and manually stop and disable Apache on\u00a0node1<\/strong>\u00a0and\u00a0node2<\/strong>:<\/p>\n
    # systemctl stop httpd\r\n# systemctl disable httpd\r\n# systemctl is-active httpd\r\n# systemctl is-enabled httpd\r\n<\/pre>\n
    \n
    \"Stop<\/a><\/p>\n
    Stop and Disable Apache Service<\/p>\n<\/div>\n
    Then run again,<\/p>\n
    # ansible-playbook \/etc\/ansible\/playbooks\/apache.yml\r\n<\/pre>\n
    This time, the task reports that the Apache web server was started and enabled on each host:<\/p>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Start Web Server<\/p>\n<\/div>\n
    Please consider the above example as a glimpse of the power of Ansible. While these are relatively easy tasks when performed on a small number of servers, it can become very tedious and time-consuming if you need to do the same in several (perhaps hundreds) of machines.<\/p>\n
    Summary<\/h3>\n
    In this article we have described how to run commands and execute complex tasks on several remote hosts simultaneously using Ansible. The\u00a0official documentation<\/a>\u00a0and the\u00a0GitHub repository<\/a>\u00a0provide a lot of examples and guides on how to use Ansible to achieve almost any imaginable task.<\/p>\n
    As you start learning how to\u00a0automate tasks on remote Linux hosts<\/a>\u00a0using Ansible, we would like to hear your thoughts. Questions, comments, and suggestions are also always welcome, so feel free to contact us using the form below any time.<\/p>\n
    In the previous two articles of this\u00a0Ansible<\/strong>\u00a0series, we explained how to install and configure\u00a0Ansible<\/strong>\u00a0to run commands and perform complex tasks in several remote servers simultaneously.<\/p>\n
    \n
    \"Automate<\/a><\/p>\n
    Automate Multiple WordPress Installations using Ansible \u2013 Part 3<\/p>\n<\/div>\n
    In the current tutorial we will explain how to set up\u00a0WordPress<\/strong>\u00a0in the same remote servers:<\/p>\n
    node1: 192.168.0.29<\/strong>\r\nnode2: 192.168.0.30<\/strong>\r\n<\/pre>\n
    where we installed, enabled, and started Apache (you probably know by now why we chose to work with a web server as an initial example in the last tutorial).<\/p>\n
    I highly encourage you to read\u00a0Part 1<\/strong>\u00a0and\u00a0Part 2<\/strong>\u00a0before proceeding further in order to make sure you\u2019re familiar with the concepts associated with Ansible.<\/p>\n
    <\/i>\u00a0How to Install and Configure \u2018Ansible\u2019 Automation Tool for IT Management \u2013 Part 1<\/a><\/p>\n
    <\/i>\u00a0How to Use Anisble Playbooks to Automate Complex Tasks on Multiple Remote Servers \u2013 Part 2<\/a><\/p>\n
    Step 1: Introducing Ansible Roles<\/h3>\n
    As you start adding more and more tasks to plays, your\u00a0Playbooks<\/strong>\u00a0can become increasingly difficult to handle. For that reason, the recommended approach in those situations (actually, in all cases) is to use a directory structure that contains the directives for each group of tasks in distinct files.<\/p>\n
    This approach allows us to re-use these configuration files in separate projects further down the road. Each of these files define what is called in the\u00a0Ansible ecosystem<\/strong>\u00a0a role.<\/p>\n
    In our case, we will create two roles. One of them (called\u00a0wp-dependencies<\/strong>) will be used to install the WordPress dependencies (PHP<\/strong>\u00a0and\u00a0MariaDB<\/strong>\u00a0\u2013 no need to install\u00a0Apache<\/strong>\u00a0as it\u2019s already installed).<\/p>\n
    The other role (named\u00a0wp-install-config<\/strong>) will include all the necessary tasks associated with the installation and configuration of WordPress.<\/p>\n
    Step 2: Creating Ansible Roles<\/h3>\n
    Ansible comes with an utility called\u00a0ansible-galaxy<\/strong>\u00a0that will help us to create the directory structure for our roles. We will do this in\u00a0\/etc\/ansible\/playbooks<\/strong>\u00a0(which we created in\u00a0Part 2<\/strong>) but in theory you can set it up in another directory if you want.<\/p>\n
    # cd \/etc\/ansible\/playbooks\r\n# ansible-galaxy init wp-dependencies\r\n# ansible-galaxy init wp-install-config\r\n<\/pre>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Create WordPress Roles<\/p>\n<\/div>\n
    Next confirms the newly created roles.<\/p>\n
    # ls -R \/etc\/ansible\/playbooks\r\n<\/pre>\n
    \n
    \"Ansible:<\/a><\/p>\n
    Ansible: Confirm WordPress Directory Structure<\/p>\n<\/div>\n
    In the above image we can see that\u00a0ansible-galaxy<\/strong>\u00a0created two directories with the same name as our roles, and other subdirectories (defaults<\/strong>,\u00a0files<\/strong>,\u00a0handlers<\/strong>,\u00a0meta<\/strong>,\u00a0tasks<\/strong>,\u00a0templates<\/strong>, and\u00a0vars<\/strong>) and a\u00a0README.md<\/strong>\u00a0file inside each of them.<\/p>\n
    In addition, a YAML file named\u00a0main.yml<\/strong>\u00a0was created inside all of the directories listed earlier, with the exception of files and templates.<\/p>\n
    We will begin by editing the following configuration files as indicated:<\/p>\n
    1.<\/strong>\u00a0\/etc\/ansible\/playbooks\/wp-dependencies\/tasks\/main.yml<\/strong>. Note that we are including\u00a0httpd<\/strong>\u00a0in case you have not followed along with the previous tutorials of this series.<\/p>\n
    main.yml<\/div>\n
    ---\r\n# tasks file for wp-dependencies\r\n- name: Update packages (this is equivalent to yum update -y)\r\n  yum: name=* state=latest\r\n\r\n- name: Install dependencies for WordPress\r\n  yum: name={{ item }} state=present\r\n  with_items:\r\n        - httpd\r\n        - mariadb-server \r\n        - mariadb\r\n        - php \r\n        - php-mysql\r\n        - MySQL-python\r\n\r\n- name: Ensure MariaDB is running (and enable it at boot)\r\n  service: name=mariadb state=started enabled=yes\r\n\r\n- name: Copy ~\/.my.cnf to nodes\r\n  copy: src=\/root\/.my.cnf dest=\/root\/.my.cnf\r\n\r\n- name: Create MariaDB database\r\n  mysql_db: name={{ wp_mysql_db }} state=present\r\n\r\n- name: Create MariaDB username and password\r\n  mysql_user:\r\n        login_user=root\r\n        login_password=YourMariaDBRootPasswordHere\r\n        name={{ wp_mysql_user }}\r\n        password={{ wp_mysql_password }}\r\n        priv=*.*:ALL\r\n<\/pre>\n
    2.<\/strong>\u00a0\/etc\/ansible\/playbooks\/wp-dependencies\/defaults\/main.yml<\/strong><\/p>\n
    main.yml<\/div>\n
    ---\r\n# defaults file for wp-dependencies\r\n  wp_mysql_db: MyWP\r\n  wp_mysql_user: wpUser\r\n  wp_mysql_password: wpP4ss\r\n<\/pre>\n
    3.<\/strong>\u00a0\/etc\/ansible\/playbooks\/wp-install-config\/tasks\/main.yml<\/strong>:<\/p>\n
    main.yml<\/div>\n
    ---\r\n# tasks file for wp-install-config\r\n- name: Create directory to download WordPress\r\n  command: mkdir -p \/opt\/source\/wordpress\r\n\r\n- name: Download WordPress\r\n  get_url: url=https:\/\/www.wordpress.org\/latest.tar.gz dest=\/opt\/source\/wordpress\/wordpress.tar.gz validate_certs=no\r\n\r\n- name: Extract WordPress\r\n  command: \"tar xzf \/opt\/source\/wordpress\/wordpress.tar.gz -C \/var\/www\/html --strip-components 1\"\r\n\r\n- name: Send config file\r\n  copy: src=\/root\/wp-config-sample.php dest=\/var\/www\/html\/wp-config.php mode=0644\r\n<\/pre>\n
    4.<\/strong>\u00a0wp-config-sample.php<\/strong>\u00a0(provided in this\u00a0Pastebin<\/a>) as follows and save it to your Ansible controller machine (as you can see in the last copy directive above, I downloaded it to the home directory of the superuser (\/root\/wp-config-sample.php<\/strong>).<\/p>\n
    Important<\/strong>: Please note that the value for variables\u00a0DB_NAME<\/strong>,\u00a0DB_USER<\/strong>, and\u00a0DB_PASSWORD<\/strong>\u00a0are the same as in\u00a0\/etc\/ansible\/playbooks\/wp-dependencies\/defaults\/main.yml<\/strong>:<\/p>\n
    wp-config-sample.php<\/div>\n
    \u2026\r\n\/** The name of the database for WordPress *\/\r\ndefine('DB_NAME', 'MyWP');\r\n\r\n\/** MySQL database username *\/\r\ndefine('DB_USER', 'wpUser');\r\n\r\n\/** MySQL database password *\/\r\ndefine('DB_PASSWORD', 'wpP4ss');\r\n\u2026\r\n<\/pre>\n
    5.<\/strong>\u00a0For new database server installations where the root password is empty, such as in this case, unfortunately we need to setup the password for user root individually in every machine through\u00a0mysql_secure_installation<\/strong>.<\/p>\n
    As far as I know, there is no available workaround that will allow you to set up the root password via\u00a0Ansible<\/strong>\u00a0in the same step where you create the administrative database account for WordPress.<\/p>\n
     <\/p>\n<\/div>\n
    Make sure you use the same password in all hosts, then copy the credentials in\u00a0\/root\/.my.cnf<\/strong>\u00a0(the actual location may differ in your case, but in all instances it needs to match the value of the\u00a0src<\/strong>\u00a0parameter for the task\u00a0Copy ~\/.my.cnf<\/strong>\u00a0to nodes in\u00a0\/etc\/ansible\/playbooks\/wp-dependencies\/tasks\/main.yml<\/strong>).<\/p>\n
    In that file (see above) we\u2019ve assumed that the password for root is\u00a0YourMariaDBRootPassword<\/strong>.<\/p>\n
    \n
    \"Ansible<\/a><\/p>\n
    Ansible Database Password<\/p>\n<\/div>\n
    6.<\/strong>\u00a0Next, our playbook (\/etc\/ansible\/playbooks\/playbook.yml<\/strong>) will look much more organized and simple when compared to the previous tutorial:<\/p>\n
    # cat playbook.yml\r\n<\/pre>\n
    \n
    \"Ansible<\/a><\/p>\n
    Ansible WordPress Playbooks<\/p>\n<\/div>\n
    - hosts: webservers\r\n  roles:\r\n        - wp-dependencies\r\n        - wp-install-config\r\n<\/pre>\n
    Finally, it\u2019s time to run these tasks by invoking our playbook:<\/p>\n
    # ansible-playbook playbook.yml\r\n<\/pre>\n
    Now let\u2019s check if we can access the WordPress Admin page using the IP addresses of\u00a0node1 192.168.0.29<\/strong>\u00a0and\u00a0node2 192.168.0.30<\/strong>:<\/p>\n
    \n
    \"Ansible<\/a><\/p>\n
    Ansible WordPress Installation<\/p>\n<\/div>\n
    You can view the last two steps in the following screencast:<\/p>\n