Ansible windows modules are those Ansible modules that are utilized to do changes on Microsoft Windows machines. The sentence structure and conduct of these modules are equivalent to other Linux-based modules with various OS explicit errands and way separators. Ansible windows modules are utilized to arrange assignments on Microsoft Windows machines. These modules are created on PowerShell for the most part rather than Python. Additionally, the association strategy like WinRM or comparative Microsoft Windows upheld ones are utilized for this situation rather than SSH.

Ansible Windows Modules have a bunch of boundaries and adequate qualities. Additionally, a portion of the boundaries has default esteems. So it turns out to be more critical to learn and comprehend the different potential outcomes. These modules have comparative punctuation as some other modules. Just we want to deal with boundaries to pass in the playbook to accomplish our assignment prerequisites.

The following is a rundown of a portion of the significant Ansible Windows Modules with a short depiction. Kindly note this rundown is just for Microsoft Windows climate and not comprehensive as there are a lot more modules which Ansible people group is continuing to create:

win_chocolatey: This is used to manage packages.

win_chocolatey_facts: To create the collation of facts for use in chocolatey.

win_chocolatey_source: To do the management of chocolatey sources.

win_chocolatey_feature: To do the management of chocolatey features.

win_acl: To set the permission of files, directory, or registry for a system group or user.

win_command: To run a command on Windows PowerShell

win_copy: To copy files to windows hosts.

win_disk_facts: To display the attached disks and related information on windows targets.

win_dns_record: To perform DNS record management.

win_domain: To ensure the Windows domain's existence.

win_domain_controller: To manage a domain controller.

win_domain_computer: To manage the Active directory Computers.

win_domain_user: To manage Active Directory Users.

win_environment: To modify the environment variables.

win_feature: To uninstall and install any Windows Feature on Windows.

win_get_url: To download files over HTTP/HTTPS/FTP.

win_hostname: To manage the computer name.

win_mapped_drive: To map the network drives.

win_package: To do package installation or uninstallation.

win_ping: To test the working setup with windows

win_wait_for: To wait for a condition to fulfill before continuing in the playbook

win_wait_for_process: To wait for a process to not exist or exist before continuing in the playbook.

win_webpicmd: Install packages on target machines using Web platform installer CLI.

win_whoami: To get the current user details.

win_iis_virtualdirectory: To configure a virtual directory on IIS.

win_iis_website: To configure a website on IIS.

win_lininfile: To put a line in the file.

Each module has a separate set of parameters and options. you can refer to the below link for the latest Ansible Windows modules, on this page you can click on a module link to get a detailed picture of that module.

In Ansible, playbooks are composed on YAML design, and each module is composed inside a playbook that should follow space and separate. Ansible Windows modules work in much the same way. In any case, there are a couple of focuses that one should keep in mind before beginning to utilize or attempting to begin the utilization of Ansible Windows modules.

PowerShell 3.0 and .NET 4.0 essentially should be introduced on track Windows

A WinRM audience ought to be made if not existing and

In the most recent arrival of Ansible, Win32-OpenSSH support was given, however, that is tested right now. It may work or not for your situation. So attempt it first in Lab

Other than WinRM, there are other association techniques like Basic,

As Windows isn't a POSIX working framework, there are numerous limits, in this way better you should attempt each arrangement in Labs

For custom new modules, you can make module code in PowerShell and afterward documentation in Python with a similar record name

In this part, we will do a few commonsense models. We will make playbooks on the Ansible regulator hub named Ansible1. Additionally, we have tartargetedndows machines as windows and WinServer1.lablad1.local. Utilizing the playbooks, we attempt to make changes or bring information from a remote objective Windows machine.

In this example, we will simply use Ansible win_ping module to check the connection and authentication success from the Ansible controller node to the target windows machine. We use the below command for the same.

In the output, you can see that connection was successfully checked.

In this example, we have a remote host named WinServer1.lablad1.local. On which we will run the command using the Ansible windows module named win_command. Then register the output in a variable named netstat. To print the output contained in variable netstat, we will use the Ansible module debug. For this task, we have a playbook like below:

-name: test cmd from win_command module hosts: lablad1.local

-name: run an executable command on remote Windows system win_command: netstat -e

ansible-playbook ansible_win_command.yaml

The Output will look like below, where you can see above, in stdout_lines, all output by running netstat

As we found in this article, Ansible Windows modules are exceptionally helpful and a piece precarious to use in the IT foundation climate. In any case, when we have decent information on these sorts of modules, we can undoubtedly do Microsoft Windows organization and functional changes. So first learn them and afterward use them.

We will know in this article, what's the Ansible Windows Modules.

Explaining of Ansible Windows Modules.

Ansible Include module which is a piece of the ansible-base and the default module accessible with the ansible establishment used to incorporate a record with a rundown of plays or assignments to be executed in the current playbook and it tends to be a solitary incorporate document the different incorporate documents, meaning it calls different playbooks errands or plays and this module likewise works for the windows targets.

This module uses the syntax “Include”.

This module allows you to specify the name of the file directly without any other options.

How does the Include module work in Ansible?

In the different programming dialects, to work on the program we partition the projects into various documents and modules, and to involve them in the content we utilize the various orders to import them so we don't have to compose the program once more.

The Include module in the Ansible works comparably. We make a playbook to run numerous errands together bringing about long playbooks once in a while which can be befuddling to comprehend and change. All things being equal, we compose the various playbooks joining one or numerous undertakings, and afterward, add them to the principle playbook.

For instance, Let's say, we want to compose the playbook which downloads the compressed document from the web, duplicates it to the objective servers, and unfasten the record at the objective envelope. Consider this all assignments are composed under the main.yml record. Our main.yml record will resemble this.

– Task1: Download the zip file from the internet.

– Task2: Copy the zip file on the target server.

– Task3: Extract the zip file at the target location.

Once we divide the above tasks into the playbooks, for example, Downloadfile.yml, copyfile.yml, and extracfile.yml respectively then we can add them into the main.yml playbook as shown below.

We can now utilize the above XML documents in numerous playbooks assuming we have a similar necessity. You can consolidate numerous choices like you can gather task1 and task2 into a single unit in the single playbook and task3 in the other playbook or task1 and task2 in the various playbooks and task3 in the primary playbook according to your necessity.

So Ansible include module has several benefits.

Helps to make the overall playbook small and organized.

Helps to get rid of the repetitive tasks by using the earlier created playbooks.

Helps when the target servers have a dependency, for example, we need to put the server into maintenance and take the servers out of maintenance which are in separate playbooks in the main playbook then you can add both the files with include module at the start and the end of the main playbook respectively.

It runs the whole playbook so if different playbooks have a similar arrangement of servers, it consumes the time and assembles the realities on numerous occasions if the gather_facts isn't incapacitated.

The underneath model shows how we can utilize the incorporate capacity to add one more playbook in the fundamental playbook.

- name: Ansible playbook to test Include module

- name: Ansible playbook to stop the spooler service

Right, when we run includepb.yml playbook,

You will get the condemned module advised considering the way that anything the Ansible interpretation you are running at present, the fuse module will be dispensed with in transformation 2.12, and a substitute strategy for using this request is import_playbook.

Let us discuss examples of Ansible Include.

Example #1: Ansible “Include” example for adding multiple playbooks.

Suppose you have the below main playbook called includepb.yml

- name: Ansible playbook for the include module

- name: Copy ansible.cfg file to the c:\temp

Now we divide both the tasks into two files called servicepb.yml and copypb.yml respectively. To include both the playbooks in the includepb.yml file,

On the off chance that you have seen, every playbook runs exclusively and accumulates current realities. So assuming you are utilizing the incorporate module for a similar arrangement of servers then it isn't so helpful. The other substitute choice is to import the undertakings rather than the playbooks utilizing include_tasks.

To run the singular undertakings then your playbooks ought to contain just the assignments.

We will know in this article, what's the Ansible Include.

Ansible Include

Introduction of Ansible directory Creation 

In Ansible, we have a few modules that are utilized for different purposes. We can involve those for our requirements utilizing different boundaries accessible with them. Additionally, we can make one module in a prearranging language like python and use it likewise. In this point, we will find out with regards to Ansible Create Directory.

One of the essential and significant modules is the record module, which is utilized for making, eliminating, refreshing the consent of documents and indexes on remote hosts. Likewise, similar undertakings should be possible involving the order module by providing orders as boundaries. In this article, we will find out with regards to it and utilizing it to make registries on remote hosts.

Making an index is an everyday activity. This should be performed while taking care of business like introducing the application, taking reinforcement and reclamation, dealing with the client's home index, allotting an amount to an envelope for a particular reason. In this way, it is vital to get a decent hold over on it utilizing Ansible and understanding its various ways, accessible boundaries, and adequate boundaries.

In Ansible we can make ccatalogsor indexes on remote hosts by utilizing under two techniques: -

Utilizing the order module and provide the order to make a catalog in plain

Involving the record module and give the catalog as the state, as its

Both of the above should be possible in two ways:

Utilizing the ansible order and give all boundaries on the order line. In any case, the result is exhaustive, additionally it's mind boggling when you have assignments to deal with numerous indexes and you will utilize contrastingly accessible

Utilizing ansible-playbook order and give a YAML record to it to decipher and execute on remote hosts. In this YAML document, you give all boundaries and choices to make an index and oversee it. This is more coordinated and simpler to utilize once you comprehend

Presently we utilize a couple of guides to see a portion of the accessible boundaries which you can use alongside making a catalog.

On the whole, let me inform you concerning the lab climate which we will utilize, where we have one ansible control server named ansible-regulator and two controllers has named have one and host-two, these are Red Hat Enterprise Linux rendition 7 as the working framework.

For creating a directory on remote hosts using the command module and pass the command to create a directory like below-using ansible: –

ansible all -m command -a "mkdir /tmp/sample_dir_1"

In the output, you may get a suggestion as a warning that there is a file module that you can use for the same purpose.

For creating a directory on remotes hosts, using the file module on the ansible command line. Use below command

ansible all -m file -a 'path=/tmp/sample_directory state=directory'

You get an output like below if the directory successfully created on the path given as parameters.

For creating a directory on remote hosts, create a YAML file, having contents like

Then use ansible-playbook command to execute the plays and tasks in this file.

You will get an output like below after successful run

For creating directory and assigning permissions at creation time, create a YAML file with contents like below

name: This Play Creates Test_1 Directory In /tmp and assign 777 permission to it hosts: all

ansible-playbook create_dir_do_permission.yaml

Create multiple directories using with_items, create a YAML file with contents like below

path: /tmp/{{ item }} state: directory with_items:

ansible-playbook create_multiple_dir.yaml

Create multiple directories using with_items and assigning different permissions to them, create a YAML file with contents like below

- name: This play creates multiple directories using with_items and assign different permission hosts: all

- name: create three directories and assiging 0777, 0755, 0644 file:

path: /tmp/{{ item.path }} mode: “{{ item.mode }}” state: directory with_items:

ansible-playbook create_multiple_dir_diff_perm.yaml

You can check on host-one and host-two as below:

Log in to each host and check directories existence and permissions:

Creating a local directory on the controller node in a playbook can be done by using local_action.

For this create a playbook with content like below:

Then run this YAML file using the ansible-playbook command line.

You can check whether a directory is created or not.

We will know in this article, what's the Ansible Create Directory.

How to create a Directory in Ansible

In Ansible, to execute undertakings and plays on remote objective machines, we want to either make the association secret phrase less or give secret word/keys progressively while running a playbook. Ansible utilizes local OpenSSH as its default association strategy. As a matter of course, Ansible thinks that we are utilizing SSH keys to interface with target remote machines.

To work with SSH we want either passwords or SSH keys of keys to the concerned client account. Ansible has an extremely valuable module named authorized_key to add or eliminate approved keys for concerning client accounts on remote machines. In this article, we will attempt to find out with regards to numerous strategies and choices to utilize this module.

An SSH key pair is a blend of two keys which are public and private. The private key is kept locally and the public key is imparted to remote hosts to which we need to associate. This mix is utilized for accomplishing unbalanced encryption, it implies is something is scrambled with one key of this mix, then, at that point, one more key of the mix is utilized to decode that. In Ansible, we are utilizing OpenSSH to make SSH associations with remote objective hubs.

We can either set up SSH association utilizing keys with controllers has by either Linux orders or Ansible itself utilizing a module named authorized_key. This module can recognize key documents for client accounts from given areas and duplicate them to remote objective machines in the predefined way (when unset, default is ~/.ssh/authorized_keys)

To make this the SSH association involving keys in Ansible. We should follow steps, which should be possible in more than one way which we will talk about in this record.

Create a key pair containing private and public keys as id_rsa and bar separately.

These will be created under ~/.ssh registry of course, on the off chance that not set in any case.

Send public key bar to remote hosts by duplicating it in record ~/.ssh/authorized_keys at end of the document.

Make ssh association with the remote host and give yes when it requests to make passage of unique finger impression of target hosts to ~/.ssh/known_hosts. On the off chance that you don't do this, then, at that point, each time the SSH association is made, the framework will request to add

This can either be done by Linux command or by using the Ansible authorized_key module. In this article, we see this Ansible module and its parameters with available options. Some of those are described below.

key: The SSH public key. It acknowledges a string or

way: Path to authorized_keys document, default is ~/.ssh/authorized_keys.

state: should the key be available or missing from record ~/.ssh/authorized_keys. The default is available.

client: The username on remote has whose approved keys document will be changed.

validate_certs: When involving HTTPS URL for the wellspring of the key record, this is utilized to set whether or not to permit approving authentication for that source site. Default is Yes

elite: This is set to eliminate any remaining non-determined keys from the approved key Default is no.

remark: To indicate the remark on the public key, here you are utilizing GitHub/GITLAB for dealing with your

manage_dir: This choice is set to advise the module to deal with the index of authorized_key

The default is yes. Note that when using the parameter path, make sure you set no for manager_dir.

Example to Implement Ansible Authorized_key

Presently by utilizing models, we will attempt to find out with regards to the Ansible authorized_key module and another way of utilizing keys to arrangement effective association with remote objective hosts, which you may need to use in everyday tasks. We will take a few models, yet before going there, we initially comprehend our lab, which we utilized for testing reasons.

Here we have an Ansible control server named ansible-regulator and two controllers have named have one and host-two. We will make playbooks and run ansible orders on the ansible-regulator hub and see the outcomes on remote hosts.

Presently in this model, we will involve an Ansible playbook to make a critical blend for a client. Then, at that point, duplicate the public key from Ansible regulator hub to remote objective hubs in ~/.ssh/authorized_keys record utilizing Ansible authorized_key

For this, we have made an arrangement. Here as of now, our playbooks are falling flat since we don't have a fruitful association with remote objective hubs. SSH keys are absent for ec2-client on regulator machine and this present client's entrance is likewise mission on remote objective machines.

ansible-playbook /var/tmp/debug_ansible_fact_l.yml

Now we create SSH public and private keys on the controller node using the below command.

ssh-keygen -q -b 2048 -t rsa -N "" -f ~/.ssh/id_rsa

Now we create a playbook like below which will use Ansible authorized module to copy the public key file to remote hosts: –

user: ec2-user state: present key: '{{ item }}'

Presently execute this playbook, however, to execute this playbook, we want to pass a private key to interface with target remote hosts on the order line with an ansible-playbook order or we can utilize boundaries to request a secret key.

In the beneath model, on the order line with ansible-playbook, we are utilizing a private key to interface with the remote objective hub, this current key's public key is now present in approved keys on remote objective machines.

By running this playbook, we are making passages in ~/.ssh/authorized_keys of remote objective machines.

ansible-playbook ansible_authorized_key.yaml --private-key /var/tmp/key_l.pem

Now when we run the same Ansible playbook which we ran previously, it will run smoothly like below. Because now we have the public key of the controller node copied to the remote target node’s authorized keys file, this has made SSH password less from the controller to remote nodes.

Dealing with all your framework from a solitary control can be very unsafe if your association strategy isn't secure, however, SSH is an extremely safe method for making associations, and SSH keys assume a significant part to make an association with remote objective hubs. Overseeing keys is streamlined with modules like authorized_key. So we should have to utilize it admirably. So learn it first and afterward use it.

We will know in this article, what's the Ansible Authorized_key.

ansible inventory

Trending Blogposts on ansible inventory

Explaining of Ansible Windows Modules.

Ansible Include

How to create a Directory in Ansible

What is Ansible Authorized_key?

Popular Discussions on ansible inventory

PRODUCTS

QUICK LINKS

LEGAL

ansible inventory

Trending Blogposts on ansible inventory

Explaining of Ansible Windows Modules.

Ansible Include

How to create a Directory in Ansible

What is Ansible Authorized_key?

Popular Discussions on ansible inventory