Inventory File

In the example, I am going to deploy Three nodes of ElasticSearch – one represent MASTER role, while other two as DATA role.

[elastic_master]
es-0001 ansible_host=172.17.0.10

[elastic_data]
es-0002 ansible_host=172.17.0.11
es-0003 ansible_host=172.17.0.12

prod.yaml

- hosts: elastic_master <------------ following actions will be performed against any host listed in elastic_master alias which found to be in inventory file
  remote_user: root <---------------- to execute the command as root
  become: true
  pre_tasks:
    - name: "Installing basic packages"
      action: yum <---------------- calls the yum module and any key that goes with with_items will be installed
              name={{ item }}
              state=installed
      with_items:
        - unzip
      when: ansible_os_family == "RedHat" <---------------- a condition such that instruct the ansible pre_tasks should only suppose to be executed on a Fedora based distribution
  roles:
   - { role: elastic_master_install }


- hosts: elastic_data
  remote_user: root
  become: true
  pre_tasks:
    - name: "Installing basic packages"
      action: yum
              name={{ item }}
              state=installed
      with_items:
        - unzip
      when: ansible_os_family == "RedHat"
  roles:
   - { role: elastic_data_install }

Default File

As we already covered this variables will be used when files which are in Jinga format are being copied under the Template DIrectory.

# vim roles/elastic_master_install/defaults

cluster_name: clusterName
node_master_true: "true"
node_data_true: "false"
node_ingest_true: "false"
path_to_log: /data/elk/logs
path_to_data: /data/elk/data
http_port: 9200
transport_tcp_port: 9300
discovery_zen_ping_unicast_hosts: '["172.17.0.10"]'

### - jvm config
init_heap_size: "-Xms8g"
max_heap_size: "-Xmx8g"

Template file Example

This is how a basic elasticsearch.yaml looks like in Jinja fromat.

# vim roles/elastic_master_install/templates/elasticsearch.yml.j2

cluster.name: {{cluster_name}}
node.name: {{inventory_hostname}}
node.master: {{node_master_true}}
node.data: {{node_data_true}}
node.ingest: {{node_ingest_true}}
path.data: {{path_to_data}}
path.logs: {{path_to_log}}
network.host: {{ansible_host}}

Task File

This is where we can define all the task that are part of the respective role, in this case task that needed to execute setting up Elasticsearch

# vim roles/elastic_master_install/tasks/main.yml

- name: Creating elk user...
  user:
    name: elk
    comment: "elk User"
    createopt: yes
    opt: /opt/elk/
    uid: 1999
    shell: /bin/bash
  become: true

- name: Copying & untar ElasticSearch5.5..
  unarchive: 
    src: /root/Ansible/ElasticSearch5/roles/elastic_master_install/Files/elasticsearch-5.5.0.tar.gz
    dest: /opt/elk/
    owner: elk
    group: elk
    mode: 0755
  become: true

- name: Creating necessary directories..
  file:
    path: /data/elk/{{ item }}
    state: directory
    owner: elk
    group: elk
    mode: 0775
    recurse: yes
  with_items:
     - [data, logs, run]
  become: true

- name: Copying the main config file...
  template: src=elasticsearch.yml.j2 dest={{elasticsearch_config_dir}}/elasticsearch.yml owner=elk group=elk mode=0644 
  become: true

Please note that I have only added files for Role “elastic_master_install” => Task/Template/Default. However, as in the prod.yaml there is another role called “elastic_data_install” which you also need to work on as did in above last three steps.

When you have the Directory Structure ready, you can initiate the Ansible by;

# ansible-playbook -i inventory prod.yaml

“I hope this has been informative for you”

The post Install ElasticSearch via Ansible appeared first on Linux Windows and android Tutorials.

How to install Ansible

Project Root Directory:

This is the top level hierarchy where everything in your ansible work should go upon. It can have any name.

Inventory File:

This file should be listed each of the server nodes that the Ansible should work on. Note that prior ssh KEY being copy is mandatory.

• [web_hosts] whatever inside this square brackets is a just alias that represent group of hosts. And that group of hosts will be invoke by the “Prod.yml” file and once it does, it send the instruction that are listed in this same yaml file. These instruction should be kind of basics, such as system updates, hostname change, etc..
• hostnames are just  yet another aliases and they don’t require any DNS entries nor hostname configured inside OS level. But they come handy when we want to call them later rather mentioning their respective IP addresses.

Prod.yml:

This is what holding the entire work-flow that suppose to be executed by Ansible. It calls aliases listed in “Inventory FIle” [ – hosts: node_master ] and by doing so we have the option to select order in which the hosts that needed to configured. Then it’s best practice to call the individual Roles here with their respective directory aliases so then each specific roles’ set of instruction will be call upon within their sub-directories rather than listed inside this main Prod.yaml file. But, as I already explained above, yet you can call some basic instruction task here under the [ KEY “pre_tasks” ]. When I say basic tasks, its like general things like update system via `yum update` or change hostname and etc..

Roles Directory:

This is where you can have Role specific sub-directories and the idea is that each of them then represent it’s own instruction set. For example, think about you want to install apahe and mysql via ansible. Then, you can have one directory, lets say “apache_role”, whose having what needed to be done on apache and on the other hand other sub-directory, called “mysql_role”, will have mysql own specific instruction. As we already covered in “Prod.yml” , we can call these sub-directories by their directory alias  when needed.

Tasks Directories:

Inside each Role Directory you can have another set of sub-directories each calling task specific instruction. In very basic Task hold a single YAML file which calls every single instruction that needed to be executed on this role, for example, install apache, configuration changes, service restarts, etc..

Default Directory:

This is where role specific environment variable are listed within a YAML file.

Template Directory:

This is what holds the sample configuration files and they suppose to be in “Jinja” format which actually holds configuration data in a variable manner so then when these configuration files are instructed to being copied, those variable are then get replaced by its own parameter that are found in the Default Directory YAML file.

OK, Now you should have a clear idea on defining your Ansible structure, else you should try to go through couple of times on each points what I explained above until yourself familiar the concept. In my next post, I will be taking real-world scenario on where we could apply Ansible automation.

“I hope this has been informative for you”

The post Getting Understand Ansible Structure appeared first on Linux Windows and android Tutorials.

Ansible is an open source project implemented in Python and has a modular architecture that can handle virtually any operating system, cloud environment and system management tool or framework.

It is included as part of the Linux Fedora distribution, inherited from Red Hat Inc. and is also available for Red Hat Enterprise Linux, CentOS and Scientific Linux through the Enterprise Linux Extras Packages (EPELs) as well as other operating systems, for example, Ubuntu and Debian.

Advantages and features

One of Ansible’s thanks to the competition is that you don’t have to install Agents or Servers. Just install ansible on your machine and you’re ready to go.

It does not require cumbersome and complicated configurations, its documentation is quite extensive and its configuration files explicit.

Another of its advantages is that it has an API and allows the development of plugins to extend its functionality.

Installing Ansible

Installing ansible is relatively easy as it is packaged for many of the most popular GNU/LINUX distributions. In the case of ubuntu 18.04 we have a PPA repository at our disposal that is ready to make the work even easier.

First of all we log in as a super user. Write in a terminal:

               sudo -i

Next we proceed to update the system, something always recommended to obtain even more security in our server:

The next step is to install the package software-properties-common:

                apt install software-properties-common

At the end of the installation, we have to add the PPA repository with the latest available version of Ansible.

               apt-add-repository ppa:ansible/ansible

The next thing to do is to install the package that contains the program:

              apt install ansible

And now, that’s it.

Getting Started with Ansible

It is easy to take the first steps with Ansible, to demonstrate its use, we must have at least two machines, one that will be the main one and the other that will act as a node.

When Ansible is installed in one of the machines, we transform it into the main one. Remembering that there is no server as such, nor agents to configure.

The main machine cannot have Windows as its operating system, and must have python 2.6 or higher for effective installation.

For this tutorial the main machine has these features:

• RAM Memory: 512mb
• OS: Ubuntu server 18.04
• IP Address: 192.168.250.5
• Hard Drive: 20gb
• Hostname: osradar1

And the second machine:

• RAM Memory: 512mb
• OS: Ubuntu server 18.04
• IP Address: 192.168.250.6
• Hard Drive: 20gb
• Hostname: osradar2

Once we know this, we proceed to start the configuration process in order to execute the first command.

First of all we must create or modify the file /etc/ansible/hosts which is where the computers of our network are defined as well as the possibility of attaching them to groups. In this file we must place the address of the other node. To edit it, proceed to execute:

              nano /etc/ansible/hosts

Now we must make sure that we have SSH key authentication with the node. Write in a terminal:

              ssh-keygen

Next, copy the public key to the node.

               ssh-copy-id -i ~/.ssh/id_rsa.pub angelo@192.168.250.6

Now we can try to perform our first command from the main machine to the node to test the installation.

          ansible all -m ping -u angelo

We can also log in with the root user. Important if we want to execute tasks that require super user.

               ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.250.6

Or any user.

Working with Playbooks

Playbooks are configuration files that allow us to deploy various tasks to different nodes, describing the steps to follow. Its writing is based on YAML and its format is.yml

For this tutorial a playbook will be made to install LAMP on the other node.

We create a playbook called lamp.yml and copy the following text into it:

                 nano lamp.yml

—
– hosts: all
user: root

tasks:

-name: General | Installing packages
action: apt pkg={{ item }} state=installed
with_items:
– php7.2
– apache2
– mariadb-server
– mariadb-client
– php7.2-mysql
– php-apcu
– php7.2-xmlrpc
– php7.2-soap
– php7.2-gd
– unzip
– python-mysqldb

– name: Apache2 |Enabling modules
action: command a2enmod rewrite vhost_alias

– name: Restart Apache
action: service name=apache2 state=restarted

Some components of the file are explained:

• hosts: to whom the playbook is addressed. It can be one, or a group, or in this case all.
• user: user that will execute it. As we know to install lamp we must be root user.
• tasks: are the instructions to be executed on the node machine. It may be one or more as in this case. The first one installs the packages, the second one enables the apache modules and the third one restarts the services.

Remember that the /etc/ansible/hosts file can be used to create groups of nodes to speed up the selection process even more.

We proceed to run the playbook with the following command:

             ansible-playbook lamp.yml

As we can see, the 4 tasks were executed correctly.

This is just an outline of the great potential of Ansible that comes to give an open and simple solution to the world of process automation and tasks within any network.

Please share this article through your social networks.

The post How to install Ansible on Ubuntu 18.04? appeared first on Linux Windows and android Tutorials.