Spacelift’s collaborative platform for infrastructure as code (IaC) enables DevOps teams to manage complex cloud infrastructures with ease. In line with our reputation as an authority on all things related to IaC management, we pride ourselves on sharing only the most precise, comprehensive, and actionable content related to our areas of expertise. See our <a href="https://spacelift.io/blog/editorial-guidelines" target="_blank">Editorial Policy</a>.

About the Spacelift blog

Faisal is an experienced IT professional with around 7 years in infrastructure and 3 years in DevOps, specializing in Azure, Azure DevOps, Terraform, Ansible, Kubernetes. Certified as an Azure Solutions Architect, focusing on cloud infrastructure and automation, ensuring efficient and scalable solutions. 

All posts by Faisal Hashem - DevOps Expert

Faisal Hashem

Author title

Going to AWS Summit London? 🇬🇧🇬🇧

Title category

Get all the latest content on Infrastructure as Code, DevOps, Spacelift features & news directly to your inbox!

Level up your IaC knowledge. Stay up to date with educational devops guides & news in infrastructure as code, cloud & more!

Managing Infrastructure at Scale | Spacelift Blog

Transform your IaC management to scale
securely, efficiently, and productively
into the future.

Blog

What Are Terraform Modules and How to Use Them: Tutorial

Terraform Functions, Expressions, Loops (Examples)

Managing Terraform State - Best Practices & Examples

Terraform For Loop - Expression Overview with Examples

What is Terraform? What is it Used For, How it Works

44 Ansible Best Practices to Follow [Tips & Tricks]

How to Stop and Remove Docker Containers

How to Create a CI/CD Pipeline with Docker [Tutorial]

CI/CD Pipeline : Everything You Need To Know

Kubernetes CI/CD Pipelines - 7 Best Practices and Tools

How to Deploy Infrastructure in CI/CD Using Terraform (Pipeline)

Terraform with Azure DevOps CI/CD Pipelines - Tutorial

Terragrunt Tutorial - Getting Started & Examples

Pulumi Pricing – Editions Overview 2024

73 Most Useful DevOps Tools to Use in 2024

Top 10 Terraform Enterprise Alternatives for 2024

Terraform Cloud/Enterprise Pricing - Tiers Overview 2024

13 Most Useful Infrastructure as Code (IaC) Tools for 2024

Terraform Cheat Sheet - 23 Terraform CLI Commands & Examples

ebook-global-banner

ebook global banner

Announcing Enhanced VCS Integration  🎉 🎉

applepodcasts

spotify

missionctrl

Welcome to missionCTRL, a show dedicated to exploring the frontiers of modern DevOps. Listen (or watch) as we sit down with the practitioners who are pushing the boundaries of development

Ansible Guides and Tutorials | Spacelift Blog

Ansible

Ansible is an open-source automation tool that simplifies configuration management, orchestration, application deployments, and cloud provisioning and ensures security and compliance. With Ansible, you gain more control over your environment and create consistency in your deployments.
In this article, we will discuss using Ansible loops as a powerful tool to manage and deploy configurations across multiple machines, eliminating the need for manual intervention. By automating these processes, you can redirect your focus to more critical tasks, ensuring continuous system updates without the burden of constant oversight.
What we will cover:
<ol>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#what-are-ansible-loops">What are Ansible loops?</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#how-to-loop-over-lists-in-ansible">How to loop over lists in Ansible</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#how-to-loop-over-dictionaries-in-ansible">How to loop over dictionaries in Ansible</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#what-is-the-difference-between-with-items-and-loop-in-ansible">Ansible with_items vs loop</a></li>
<li aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#how-to-loop-a-block-in-ansible">How to loop a block in Ansible?</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#how-to-use-multiple-loops-in-ansible-nested-loops">How to use multiple loops in Ansible? (Nested loops)</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#ansible-loop-control">Ansible loop control</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#conditional-loops-in-ansible">Conditional loops in Ansible</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-loops#best-practices-for-using-loops-in-ansible">Best practices for using loops in Ansible</a></li>
</ol>

Loops in Ansible are sets of instructions that automate repeated tasks, making it easier to perform the same action multiple times without manual repetition. They work similarly to other basic programming looping concepts such as for_each or while. Ansible loops can be used, for example, for installing multiple packages, creating numerous users, or modifying a set of files.
When using Ansible loops you also reduce the possibility of human errors, as consistency is guaranteed regardless of the complexity of the task. Ansible&#8217;s straightforward syntax and the ability to include detailed logging provide clear visibility into operations, improving troubleshooting and accountability.
There are many ways to use loops throughout <a href="https://spacelift.io/blog/ansible-playbooks" target="_blank" rel="noopener">Ansible playbooks</a>, for example: 
<ul>
<li style="font-weight: 400;" aria-level="1">Adding conditionals with your loops for more flexibility</li>
<li style="font-weight: 400;" aria-level="1">Looping through lists and dictionaries</li>
<li style="font-weight: 400;" aria-level="1">Nesting your loops to manage complex or hierarchical data structures</li>
<li style="font-weight: 400;" aria-level="1">Using loop controls to customize the way your loops are being run</li>
</ul>
Let&#8217;s dive deeper into those use cases.

The simplest form of looping in Ansible is to iterate over a list of items, taking each item, inputting it into the playbook task, and running it each time using the input. This comes in handy when you have a long list of packages you want to install across the Linux boxes in your environment. Instead of creating a single task for each one of these packages, you can condense your code and create a list of the packages’ names. 
Note: We will be using a Debian-based distribution for our examples, but the same concept should apply to other distributions.
<h3>Example 1 &#8211; Deploying multiple packages on a Linux box</h3>
Here is a simple example of using Ansible loops to deploy multiple packages on a Linux box:

<h3>Example 2 &#8211; Using loops to create users and copy files</h3>
As we’ve seen above, we can easily use lists to install multiple packages across your Linux boxes. However, we can also utilize lists to create users and copy files across different directories. 
The playbook below utilizes lists and loops to ensure multiple users are present throughout the Linux boxes:

We can also use lists and loops to copy a single file across different directories:

Using Dictionaries in the Ansible looping feature can be very useful and make your playbooks more efficient and easier to manage. Dictionaries allow you to iterate over key-value pairs and perform operations on multiple items at once with its own set of values. This provides more scalability and flexibility throughout the playbook as you can add more items to your dictionary without changing the logic of your tasks. 
You can also combine dictionaries with different environmental variables using <a href="https://spacelift.io/blog/ansible-inventory" target="_blank" rel="noopener">Ansible inventories</a> or facts, making them more dynamic. 
Here are some examples of using dictionaries across your playbooks.
<h3>Example 1 &#8211; Using the lookup filter</h3>
In the following example, we check if multiple services are managed properly.
In the loop, we state that it needs to use the <code>lookup</code> filter to search for the dictionary ‘services’, where you can reference the key and values. You can also set default values if any dictionary values are missing (e.g., mysqld).

<h3>Example 2 &#8211; Using the dict2items filter</h3>
We can also use dictionaries to assign UIDs to usernames. 
In the following example, we assign all of our key value pairs under vars and use the <code>dict2items</code> filter to transform the dictionary into a list of dictionaries. This is useful when iterating over a dictionary using loops since the loop feature works directly with lists. 
We didn’t use the <code>dict2items</code> filter in the previous example because the <code>lookup</code> filter with <code>dict</code> directly retrieves the dictionary for iteration and allows you to access the key and values without transforming the dictionary to a list as <code>dict2items</code> does.

Historically, Ansible <code>with_items</code> was used to perform looping functions throughout playbooks. Due to its limitations, loops were introduced in Ansible 2.5.  Even though Ansible’s <code>with_items</code> is still functional and not yet deprecated, according to Ansible’s documentation, loops are the recommended way of introducing looping constructs in your code.
Loops provide much more flexibility than <code>with_items</code> for tasks outside of simple lists.  They can also be used with other Ansible filters and plugins, such as dictionaries, combining lists, conditionals, nested loops, and more. 
Below is a comparison example of using <code>with_items</code> to create users from a simple list and another example of using loops to create users with specific UIDs assigned to each user.
Using <code>with_items</code>:

Using loops:
Here, <code>item.0</code> represents the user names and <code>item.1</code> represents the UID values in the zip filter, assigning mjordan a UID of 1001 and so on.

<ul>
<li><a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">How to better manage Ansible and overcome challenges</a></li>
<li><a href="https://spacelift.io/blog/infrastructure-problems-that-spacelift-solves" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;Common Infrastructure Challenges and How to Solve Them&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">Common infrastructure challenges and how to solve them</a></li>
<li><a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;44 Ansible Best Practices to Follow [Tips &amp; Tricks]&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">44 Ansible best practices to follow</a></li>
</ul>

Neither loops nor <code>with_items</code> can be used with blocks in Ansible. Alternatively, you could use <a href="https://docs.ansible.com/ansible/latest/collections/ansible/builtin/include_tasks_module.html" target="_blank" rel="nofollow noopener"><code>include_tasks</code></a> to achieve a similar result and include task files based on specified conditions.

You can use multiple loops in Ansible by nesting loops within each other. Nested loops are loops within loops that allow you to iterate over complex data structures and perform multiple iterations within a single task. They can be useful if you need to deploy multiple applications across different environments, set up multiple services with distinct configurations, or manage permissions for multiple users. 
Below is a simple example using nested loops with the subelements lookup option, which is needed when working with nested lists. 
Subelements take two arguments. The first is the list of dictionaries in your primary list, and the second is the keys within each dictionary (which includes the “subelements” — the list of items you want to iterate over). This allows you to perform operations on each sub-element related to its parent element in a single loop. Using nested loops in this example reduces the complexity and makes the playbook more readable. 
In this example, we display the key and values of the nested dictionary and query through the dictionary to display the environments with their specific URL:

The nested list will return each application and its URL for development and production, displaying four results:

You can use many different options to manage and customize the flow of your Ansible loops. 
The key features of the <code>loop_control</code> keyword include:
<ul>
<li style="font-weight: 400;" aria-level="1"><code>pause</code> — This option allows you to pause your loop for a specific time (in seconds) between each iteration. For example, it can be useful when you need to place a timer after the first iteration to the next iteration due to interacting with specific APIs that have rate limits. </li>
<li style="font-weight: 400;" aria-level="1"><code>index_var</code> — The <code>index_var</code> option lets you access the index of the current loop that is running, which might be helpful when you need to access the position of the current item in the loop. </li>
<li style="font-weight: 400;" aria-level="1"><code>loop_var</code> — This option allows you to customize the ‘item’ variable name used in the loop. You can use this to improve the readability of your playbook by specifying a familiar and descriptive name. </li>
<li style="font-weight: 400;" aria-level="1"><code>extended</code> — The <code>extended</code> option was added in Ansible version 2.8. Using this option, you can pull additional details of the loop (e.g., the current item’s index and the total number of items), which is helpful for debugging. </li>
</ul>
Below is a simple example of how you can use the <code>loop_control</code> <code>pause</code> feature to add a five-second pause between each loop iteration:

Here is another example of using the <code>pause</code> and <code>loop_var</code> feature of <code>loop_control</code> to perform a REST API call to a service that limits the number of requests you can make per minute:

Conditional loops in Ansible allow you to control the loop iteration and under what conditions it should continue. They are very useful in tailoring your playbook to execute tasks dynamically and ensuring specific actions are run only when the conditional criteria are met. 
If you are familiar with regular conditionals in Ansible, you know that you can utilize the when statement for many situations. The same applies for loops. You could use the when statement in loops to filter items based on their attributes or values and specific variables and skip iterations if the results from the previous run did not meet the conditional criteria. 
Here is an example of using the conditional loops with the when statement to retrieve the OS of the machine you are running against using <code>ansible_facts</code>, enable nginx service and disable httpd service on Debian-based OS:

In the next example, we will be using the conditional loops to find out if the packages in the loop are installed, and if they are not installed, the playbook will install the package:

You should consider the following best practices when running loops in Ansible:
<ol>
<li style="font-weight: 400;" aria-level="1">Minimize tasks inside loops — To ensure your loops run cleanly, try not to overburden your loop task with extras and place the necessary tasks within the loop to reduce execution time. </li>
<li style="font-weight: 400;" aria-level="1">Use <code>failed_when</code> and <code>changed_when</code> — These options may be useful in scenarios when tasks don’t have a straightforward success/failure condition, as they can ensure idempotency and give predictable outcomes.</li>
<li style="font-weight: 400;" aria-level="1">Use <code>when</code> properly — Place the <code>when</code> condition outside of your loops, as it can cause unnecessary iterations if not used correctly. </li>
<li style="font-weight: 400;" aria-level="1">Limit nesting levels — Make sure your nested loops are not too deep, as they can become difficult to read and maintain. Consider spreading them into multiple tasks or utilize include_tasks to break up the logic into smaller, manageable pieces. </li>
<li style="font-weight: 400;" aria-level="1">Use the <code>loop_control</code> features — The <code>loop_contol</code> option contains way too many useful features to ensure your playbook outputs are clean and easy to debug. </li>
<li style="font-weight: 400;" aria-level="1">Don’t use <code>ignore_errors</code> in loops all the time — Make sure you test and know where you are applying this statement, as it can cause critical errors to be overlooked during playbook runs.</li>
<li style="font-weight: 400;" aria-level="1">Keep it simple — Ensure the conditionals and nested loops in your playbook are neat and clean. If not managed properly, your playbook will eventually become unreadable and difficult to debug during issues.</li>
</ol>

<a href="https://spacelift.io/" target="_blank" rel="noopener">Spacelift</a>’s vibrant ecosystem and excellent GitOps flow can greatly assist you in managing and orchestrating Ansible. By introducing Spacelift on top of Ansible, you can then easily <a href="https://docs.spacelift.io/concepts/policy/trigger-policy" target="_blank" rel="noopener">create custom workflows</a> based on pull requests and apply any necessary <a href="https://docs.spacelift.io/concepts/policy/terraform-plan-policy" target="_blank" rel="noopener">compliance checks</a> for your organization. Another great advantage of using Spacelift is that you can manage different infrastructure tools like Ansible, Terraform, Pulumi, AWS CloudFormation, and even Kubernetes from the same place and combine their <a href="https://docs.spacelift.io/concepts/stack/" target="_blank" rel="noopener">Stacks</a> with building workflows across tools.
If you want to learn more about Spacelift working with Ansible, check our <a href="https://docs.spacelift.io/vendors/ansible/" target="_blank" rel="noopener">documentation</a>, read our <a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">Ansible guide</a> or <a href="https://spacelift.io/schedule-demo" target="_blank" rel="noopener">book a demo with one of our engineers</a>.

Loops are very handy in <a href="https://spacelift.io/blog/ansible-tutorial" target="_blank" rel="noopener">Ansible</a> as they can minimize your code and create more efficiency. They are great for automating repetitive tasks, managing complex configurations, and implementing conditionals in your playbooks. As we covered in this article, we can use loops to iterate over lists, dictionaries, handling nested loops, applying specific conditionals, or utilizing loop controls and all of its features, we can harness the true power and flexibility of automation in Ansible. For debugging purposes, it is important that we ensure our playbooks are clean, readable, and not overly complicated using conditionals and nested loops.

Spacelift helps you manage the complexities and compliance challenges of using Ansible. It brings with it a GitOps flow, so your infrastructure repository is synced with your Ansible Stacks, and pull requests show you a preview of what they’re planning to change. It also has an extensive selection of policies, which lets you automate compliance checks and build complex multi-stack workflows.

Using Ansible Shell Module to Execute Remote Commands

How to Create Ansible Template [Examples]

How to Use Different Types of Ansible Variables (Examples)

Flavius Dinu

What are Ansible loops? Learn how to loop over lists and dictionaries in Ansible. See examples. With_items vs loop explained.

377-ansible-loop

ansible loop

Ansible Loops : How To Use, Tutorial & Examples

Want to level up your Kubernetes knowledge? Explore our tutorials and step-by-step guides written by Kubernetes experts. Learn Kubernetes best practices and solutions to the most difficult problems.

Kubernetes Guides and Tutorials | Spacelift Blog

Kubernetes

Kubernetes is an open-source orchestration platform that simplifies managing containerized applications by automating tasks like scaling, load balancing, and resource allocation across clusters of machines. Its capabilities allow for a declarative management style comparable to Ansible, focusing on the application code rather than environmental issues.
Ansible, an automation tool for IT infrastructure, streamlines repetitive tasks, configuration management, and deployment through a server-client architecture. It utilizes playbooks for orchestration across managed nodes via SSH or WinRM. It leverages YAML&#8217;s declarative language and idempotency to avoid redundant deployments, promoting reusable code through roles for efficient application deployment. 
Integrating Ansible with Kubernetes helps with resource deployment by harnessing the strengths of both platforms for efficient infrastructure and application management.
What we will cover:
<ol>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#why-manage-kubernetes-with-ansible">Why manage Kubernetes with Ansible?</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#prepare-the-environment-to-run-ansible-with-kubernetes">Prepare the environment to run Ansible with Kubernetes</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#how-to-deploy-kubernetes-cluster-with-ansible">How to deploy Kubernetes cluster with Ansible</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#how-to-manage-kubernetes-resources-with-ansible">How to manage Kubernetes resources with Ansible</a></li>
<li aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#how-to-deploy-ansible-playbook-to-kubernetes-on-a-cloud-provider">How to deploy Ansible playbook to Kubernetes on a cloud provider</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#how-to-use-ansible-for-cicd-in-kubernetes">How to use Ansible for CI/CD in Kubernetes</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#automate-kubernetes-updates-and-upgrades-with-ansible">Automate Kubernetes updates and upgrades with Ansible</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-kubernetes#how-spacelift-can-help-you-with-ansible-and-kubernetes-projects">How Spacelift can help you with Ansible and Kubernetes projects</a></li>
</ol>

Kubernetes is a powerful tool that helps save resources and costs. However, it&#8217;s a bit complex to set up and manage, as you use the command line and run ‘kubectl’ each time you want to deploy a Kubernetes resource. This process still requires some manual work and increases your margin of error. 
This is comparable to a Linux environment. You can either run commands one by one or create a complex bash script that is not easily readable. 
The way Ansible revolutionized Linux application deployments, you can now also do with Kubernetes using the kubernetes.core.k8s module. This module introduces an abstraction layer that simplifies Kubernetes setups into a more manageable and readable format.
Ansible allows you to use logic and variables to deploy the same playbook consistently to different environments. <a href="https://spacelift.io/blog/ansible-modules" target="_blank" rel="noopener">Ansible contains a large library of modules</a> for specific tasks in the Linux environment, but a small library of modules is needed for Kubernetes. The reason is that Ansible and Kubernetes both use <a href="https://spacelift.io/blog/yaml" target="_blank" rel="noopener">YAML’s declarative syntax</a>, which allows Kubernetes code to be directly embedded into Ansible’s playbook task and allows them to complement each other.
Another benefit of using Ansible is that you can use one tool to deploy the infrastructure and application layers of a full Kubernetes ecosystem. As you will see below, we will be utilizing Ansible to deploy our <a href="https://spacelift.io/blog/kubernetes-cluster" target="_blank" rel="noopener">Kubernetes cluster</a> and an application on Kubernetes. 
<h3>Ansible vs. Helm</h3>
Many people gravitate towards using Helm charts for their Kubernetes Deployments, appreciating the ability to bundle up all the Kubernetes Manifest files into a single Helm chart, inject variables, manage release versions, and deploy applications with one command. While Helm excels in Kubernetes-only environments by offering streamlined deployment processes, integrating it with Ansible can elevate the deployment strategy even further. 
With its idempotent nature and extensive module support, Ansible introduces flexibility and the capability to handle more certain deployment scenarios, including conditional operations and integration with external systems. This combination of Ansible features allows for a sophisticated automation strategy that Helm charts alone might be limited to due to their focus on Kubernetes. 
Starting with Ansible will provide immediate benefits and ensure adaptability for future needs, particularly for users new to Kubernetes. For environments that are already utilizing Helm, the integration is made smoother with Ansible’s ‘kubernetes.core.helm’ module, which uses Helm package management. 
Utilizing both Helm and Ansible allows you to maximize both tools, which offers a comprehensive approach to managing Kubernetes deployments across various scenarios and tools.
<h3>Ansible vs. GitOps</h3>
In modern Kubernetes application deployment and scaling environments, GitOps tools like <a href="https://spacelift.io/blog/argocd" target="_blank" rel="noopener">ArgoCD</a> and Flux are becoming the standard for automation of the build-to-deployment process, complementing CI/CD pipelines.
Ansible integrates into this ecosystem by focusing on orchestrating initial setup tasks such as configuring Kubernetes clusters, setting up network policies, storage solutions, and other cloud infrastructure essentials. It excels in pre-deployment and post-deployment tasks, which facilitates a solid deployment strategy. 
Ansible also works very well in managing diverse environments (Dev, QA, UAT, Prod) in your CI/CD setup with varying configurations and secrets. For hybrid and multi-cluster Kubernetes setups across various cloud and on-premises, Ansible ensures consistent and uniform automation.
For this article, I will use Ansible to deploy a full Kubernetes Cluster (1 Master Node and 2 Worker Nodes) using Ansible Playbooks, deploy a Kubernetes Task Manifest through an Ansible Playbook, utilize a Cloud Providers Kubernetes Cluster (Azure AKS), incorporate Ansible in a CI/CD pipeline, and manage updates and upgrades.

Before starting with Ansible and Kubernetes setup, let&#8217;s outline the architecture to understand how Ansible communicates with Kubernetes clusters. 
We&#8217;ll have an Ansible Control Node that connects to a Proxy machine. This Proxy machine allows us to execute kubectl commands, facilitating access to various Kubernetes clusters. After establishing a link from the Ansible Control Node through the Proxy to the Kubernetes cluster, we&#8217;ll test some playbooks to confirm everything is operational. 
Note: Kubernetes module in Ansible doesn&#8217;t come with kubectl tools for running tasks. You&#8217;ll need to install kubectl on the Proxy machine and ensure the ~/.kube/config file includes the clusters you intend to deploy to. This setup process will be explained in more detail later in this article.
On the Ansible Control Node, direct your playbook to the Proxy machine. 
<ul>
<li style="font-weight: 400;" aria-level="1">For using Ansible locally, specify &#8216;localhost&#8217; under the hosts</li>
<li style="font-weight: 400;" aria-level="1">For a remote proxy, input the server&#8217;s name/IP. </li>
<li style="font-weight: 400;" aria-level="1">For setups with multiple proxies leading to different clusters, you can create an inventory file with groups of servers. This file is then used as the &#8216;hosts&#8217; in your ansible-playbook command, allowing for precise control over where playbooks are run. </li>
</ul>
We&#8217;ll follow the architecture in the diagram below to execute our playbooks on Kubernetes clusters.

ansible-kubernetes-example

deploy kubernetes with ansible

To have Ansible run against a Kubernetes cluster, you will need the following setup before we continue. 
<ul>
<li style="font-weight: 400;" aria-level="1">Ansible Control Node</li>
<li style="font-weight: 400;" aria-level="1">Proxy Machine (kubectl tools/kube config/python3) &#8211; might be easier if this is a Linux box</li>
<li style="font-weight: 400;" aria-level="1">Kubernetes cluster (either on-prem or using a cloud provider)</li>
<li style="font-weight: 400;" aria-level="1">SSH connectivity enabled between Ansible Control Node and Proxy Machine</li>
</ul>
Please note that I will be using the Debian OS family (apt) for my examples. However, the same should work for any other Linux distribution.
<h3>1. Set up Ansible Control node</h3>
On your Ansible Control node, run the following to install Kubernetes Collection (this includes the module and plugins):

<h3>2. Configure Proxy Machine with Kube Config and Kubectl tools</h3>
On the proxy machine, we will install kubernetes tools so we can use kubectl, cloud provider CLI tools (Azure CLI, AWS CLI, etc.) to connect to our Kubernetes cluster in the cloud. You can also manually add your Kubernetes clusters config onto the Proxy (~/.kube/config). 

In our example, we will be using a Ubuntu Proxy that will connect to my Azure Kubernetes Cluster:

Now that we have verified we can access our Kubernetes cluster from our proxy, we can move on to configuring our Ansible playbooks to run against our kubernetes cluster from our Ansible control node.

To use <a href="https://spacelift.io/blog/ansible-playbooks" target="_blank" rel="noopener">Ansible playbook</a> to configure your Kubernetes cluster, you will need the following:
<ul>
<li style="font-weight: 400;" aria-level="1">All nodes should be Ubuntu 22.04 LTS to follow this example</li>
<li style="font-weight: 400;" aria-level="1">1 Master Node &#8211; Minimum 2GB CPU &amp; 4GB RAM</li>
<li style="font-weight: 400;" aria-level="1">2 Worker Nodes &#8211; Minimum 2GB CPU &amp; 4GB RAM</li>
<li style="font-weight: 400;" aria-level="1">SSH connectivity between Ansible and each of these Nodes (use ssh-copy-id username@node-ip from Ansible Control Node to copy your Public key over to these nodes)</li>
</ul>
Let&#8217;s go into our Ansible Control Node and create our inventory file kube_inventory (no extension needed) under ~/ansible/inventory and edit the file to include our Kubernetes nodes:

Now, under ~/ansible/playbooks, add the following playbook kube_dependencies.yml to deploy your Kubernetes dependencies across all of your nodes (master and worker nodes). 
I have packed this up into one playbook since we will need to install and configure all of the following into all of the nodes for our Kubernetes cluster.

To run the Dependency Playbook, use the following from your Ansible Control Node:

Once you have successfully deployed the dependencies across all of your nodes, we can go ahead and initialize your Master node with Kubernetes. Run the following to create kube_master.yml playbook under ~/ansible/playbooks/. 
Please make sure to replace YOUR_USERPROFILE_NAME with the name of your user profile that is in your /home/ directory that you are installing Kubernetes under. (For example, I am using ‘kube_admin’).

To run the master playbook, use the following from your Ansible Control Node:

Once we have successfully deployed this to the master node, we can jump into deploying the following to our worker nodes to connect our worker nodes to the master node. Let&#8217;s create kube_workers.yml under ~/ansible/playbooks/. 
Please make sure to replace YOUR_MASTER_IP with the IP address of your master node and also replace YOUR_USERPROFILE_NAME with the name of your user profile that is in your /home/ directory that you are installing Kubernetes under.

To run the worker nodes playbook, use the following from your Ansible Control Node:

Once the playbook runs successfully, you can validate the cluster is working properly by running the commands below from the Master Node:

We will now add the kube config of the master node to our /etc/kube/config of our proxy. 
From the master node, you can run the command below to copy the config over to your proxy:

You can validate under your ~/.kube/config in your proxy machine to make sure you view the config and also run the following from your proxy to make sure you can access your cluster from your proxy:

The next step is to deploy the Kubernetes task manifest from our Ansible Control Node. 
But overall, you can see how much time we can save on setting up and configuring a Kubernetes cluster using Ansible. 
You can easily add another Ubuntu server in your <a href="https://spacelift.io/blog/ansible-inventory" target="_blank" rel="noopener">Ansible inventory file</a> and run the playbooks to add another node into your Kubernetes cluster. You have more control over the state of your Kubernetes Nodes.

<ul>
<li><a href="https://spacelift.io/blog/how-to-maintain-operations-around-kubernetes-cluster" target="_blank" rel="noopener">How to maintain operations around Kubernetes cluster</a></li>
<li><a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">How to better manage Ansible and overcome challenges</a></li>
<li><a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;44 Ansible Best Practices to Follow [Tips &amp; Tricks]&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">44 Ansible best practices to follow</a></li>
</ul>

Before we start, validate that you are able to ping your proxy from your Ansible control node to ensure you have connectivity.
Let’s modify our inventory file to include the proxy now (~/ansible/inventory/kube_inventory) that will contain the proxy IP or Host Name (if you have DNS configured).
Add your proxy to your inventory as below:

Let’s create a simple playbook file as create_namespace.yml in ~/ansible/playbooks/ as the following to create a namespace in your Kubernetes cluster:

You can also pass in your Kubernetes task manifest as a file into your Ansible playbook:

Now all you have to do is just run your ansible playbook command:

Once the playbook run is complete, go to your proxy and validate that you are able to see the namespace created by running the following:

And there you have it: you have just used Ansible to deploy a Kubernetes task manifest to your Kubernetes cluster. 
Here are some other playbooks (Deployments, Services, and Configmaps) you can test running from your Ansible Control node. You can utilize the following Application/Service Deployment task manifest to deploy a nginx application:

You can also manage your Kubernetes environment variables with Ansible using a configmap:

Nowadays, we mostly navigate towards a PaaS solution for our Kubernetes cluster, as it will be hosted by Azure, AWS, GCP, or others. I want to briefly cover how you would connect an Azure AKS cluster to your Ansible &#8211; proxy workflow. The same process will follow for Amazon EKS and Google GKE with their dedicated CLI commands. 
Let’s go to our Proxy machine and run the code below. We will install the Azure CLI tools and use ‘az login’ to log in to Azure. This will validate that we are able to connect to our AKS cluster from our proxy and make sure that we have the kube config in our proxy updated.

Once we validate we can access our AKS cluster nodes and other resources, we can move to the Ansible Control Node and run some of the previous playbooks against the proxy.

Run your ansible playbook command:

Once the playbook run is complete, go to your proxy and validate you are able to see the namespace created by running the following:

We have confirmed we can run playbooks against our Azure AKS cluster. 
One thing to note is that we replaced the existing /.kube/config with the Azure AKS cluster config. Typically, you will have a multi-cluster environment and will need to add different config files in your ~/.kube/ location and configure your Ansible playbooks to point to the correct config file using the following:

Implementing Ansible in your <a href="https://spacelift.io/blog/ci-cd-pipeline" target="_blank" rel="noopener">CI/CD workflows</a> consists of two main methods. 
<ul>
<li style="font-weight: 400;" aria-level="1">Use Ansible in a Jenkins Pipeline setup for CI/CD, which allows for direct deployment and configuration of Kubernetes resources from within the pipeline. Jenkins can trigger Ansible playbooks as part of the deployment process and apply the changes directly to the Kubernetes cluster. This is an ideal approach if you are looking for a more hands-on, scriptable method to manage Kubernetes deployments. 
</li>
<li style="font-weight: 400;" aria-level="1">Integrate Ansible with a CI/CD GitOps tool for Kubernetes, such as ArgoCD or Flux, as these tools will focus more on the pre-processing steps that are needed to generate the Kubernetes manifests before deployment. Since ArgoCD/Flux focuses on reading the Git Repository for Kubernetes manifest file changes, you can add a step in your CI/CD pipeline to trigger an Ansible playbook to dynamically generate or update the manifest files in the repository based on configurations and environments through jinja2 templates. Ansible&#8217;s strength is that it can handle all idempotent operations, which ensures consistent deployments without unnecessary reconfigurations.</li>
</ul>
Read also: <a href="https://spacelift.io/blog/infrastructure-as-code-with-generic-ci-cd" target="_blank" rel="noopener">Why Generic CI/CD Tools Will Not Deliver Successful IaC</a>
<h3>Ansible in a Jenkins CI/CD Pipeline</h3>
Here is an example of how you would use Ansible to deploy Kubernetes manifest in a Jenkins CI/CD Pipeline:
Jenkins file:

<h3>Integrating Ansible with a CI/CD GitOps tool</h3>
The following is a short example of how Ansible can be used alongside your ArgoCD setup to perform your pre-processing steps to create or update the Kubernetes manifest files in a Git repository:
Playbook to copy Jinja template over Kubernetes manifest application deployment:

Sample variable file (for production environment) used for Jinja Template:

Now, create a step in your CI/CD pipeline build steps (Jenkins, GitHub Actions, Azure DevOps etc) to trigger the Ansible Playbook and perform a Git Commit and Push for your Git repository that contains the Kubernetes Manifest files.
If you have ArgoCD already set up, this should just trigger your ArgoCD workflow to sync and update the existing Kubernetes application. If you are deploying a new application, you can run the following Argo CD commands:

Once the sync is completed, you can monitor your Kubernetes deployment to ensure it is running as expected. 
As you can see, this workflow would automate your deployment process by leveraging Ansible for configuration management and manifest creation and utilizing ArgoCD for continuous deployment, following GitOps principles.

Ansible is also great at managing updates for your resources in a Kubernetes cluster due to Ansible’s idempotent nature, which minimizes the risk of any configuration drift and ensures all of your kubernetes resources are in their desired state. 
Ansible integrates with Kubernetes modules, which provides an easy way to communicate with Kubernetes API and perform update operations such as rolling updates and canary deployments. 
The example below illustrates how you would deploy Rolling Updates to your Kubernetes cluster using Ansible. This update method deploys updates to your pods one by one. As one old pod goes down, a new pod with the preferred image goes up, which ensures minimal downtime and a smooth transition between old and new versions of your application.

You can also utilize Canary deployments, which focus on deploying the new version of your application to a canary group (small group of pods) and gradually increasing the traffic to the preferred version while monitoring the application&#8217;s performance.
Here is an example:

You can also use Ansible to manage updates to your Kubernetes cluster nodes, such as updating the version of your kubelet, kubeadm, kubectl, containerd, networking, docker or any security tools. In the following examples, we perform these updates across all of the Kubernetes nodes.
<ul>
<li>Kubeadm updates:</li>
</ul>

<ul>
<li>Upgrading <a href="https://spacelift.io/blog/kubernetes-networking" target="_blank" rel="noopener">Kubernetes cluster networking</a>:</li>
</ul>

Spacelift supports both <a href="https://docs.spacelift.io/vendors/ansible/" target="_blank" rel="noopener">Ansible</a> and <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">Kubernetes</a> and enables users to create <a href="https://docs.spacelift.io/concepts/stack/" target="_blank" rel="noopener">stacks</a> based on them. Leveraging Spacelift, you can build CI/CD pipelines to combine them and get the best of each tool.
It brings with it a GitOps flow, so, for example, your Kubernetes Deployments are synced with your Kubernetes Stacks, and pull requests show you a preview of what they’re planning to change. It also has an extensive selection of <a href="https://docs.spacelift.io/concepts/policy/" target="_blank" rel="noopener">policies</a>, which lets you <a href="https://docs.spacelift.io/concepts/policy/terraform-plan-policy" target="_blank" rel="noopener">automate compliance checks</a> and <a href="https://docs.spacelift.io/concepts/policy/trigger-policy" target="_blank" rel="noopener">build complex multi-stack workflows</a>.
Another great advantage of using Spacelift is that you can manage more infrastructure tools like OpenTofu, Terraform, Pulumi, and AWS CloudFormation from the same place and combine their <a href="https://docs.spacelift.io/concepts/stack/" target="_blank" rel="noopener">Stacks</a> with building workflows across tools. 
If you want to learn more about Spacelift, <a href="https://spacelift.io/free-trial" target="_blank" rel="noopener">create a free account today</a> or <a href="https://spacelift.io/schedule-demo" target="_blank" rel="noopener">book a demo with one of our engineers</a>.

Leveraging Ansible to deploy your Kubernetes environment and resources in your Kubernetes cluster can streamline your workflows and give you more control over all the pieces involved. From Node deployments to Kubernetes Task Manifest deployments, you have visual flexibility in managing these resources with Ansible. Ansible is fully supported amongst all CI/CD pipelines and can streamline all of your deployments even further with certain pre/post processing tasks that will ensure a smooth and automated flow of code to your Kubernetes clusters.

Spacelift helps you manage the complexities and compliance challenges of using Ansible and Kubernetes. It brings with it a GitOps flow, so your infrastructure repository is synced with your Ansible Stacks, and pull requests show you a preview of what they’re planning to change.

Transform your IaC management to scale securely, efficiently, and productively into the future.

ebook-sidebanner

ebook bottom overlay

7 Ansible Use Cases - Management & Automation Examples

Paweł Piwosz

Discover ways to deploy Kubernetes with Ansible. See examples of managing resources, creating a Kubernetes cluster using Ansible, and more.

366-kubernetes-with-ansible

kubernetes with ansible

How to Manage Kubernetes with Ansible [Tutorial]

Although Linux systems can access several well-regarded configuration management tools like Chef and Puppet, these can be more complicated than necessary for some users. As an alternative, Ansible stands out because its straightforward architecture eliminates the need to install specific software on nodes. It leverages SSH for performing automation tasks and utilizes YAML files to outline provisioning specifics.
In this post, we will install Ansible across various Operating Systems such as Ubuntu, RHEL, CentOS, MacOS, and Windows.
What we will cover:
<ol>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#what-is-ansible">What is Ansible?</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#installing-ansible-with-pip">Installing Ansible with pip</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#how-to-install-ansible-on-ubuntu">How to install Ansible on Ubuntu</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#how-to-install-ansible-on-rhel">How to install Ansible on RHEL (Linux)</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#how-to-install-ansible-on-centos">How to install Ansible on CentOS</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#how-to-install-ansible-on-macos">How to install Ansible on macOS</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#how-to-install-ansible-on-windows-os">How to install Ansible on Windows</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/how-to-install-ansible#testing-the-ansible-setup">Testing the Ansible setup</a></li>
</ol>

Ansible lets you perform configuration management, task automation, security/compliance tasks, orchestration, cloud provisioning, and application deployment easily and in an automated fashion. In simple terms, Ansible follows a master-slave architecture — you have an Ansible control node, where you will trigger and manage your jobs (playbooks), and managed nodes, the machines you want to run the playbooks on (inventory). 
Ansible only needs SSH connectivity to establish connectivity to the managed nodes. For Windows, Ansible utilizes WinRM. These playbooks contain anything you want to perform on your managed nodes, such as installing an application, copying files over, ensuring certain config files are set up properly, removing unwanted files, etc. You can utilize inventory files to specify the managed nodes on which you want to run these playbooks.
Ansible was designed in a way that does not require many dependencies; the only application needed on each machine (control node and managed nodes) is Python and a few support libraries. 
Ansible uses a declarative language, <a href="https://spacelift.io/blog/yaml" target="_blank" rel="noopener">YAML</a> and focuses on keeping everything idempotent, ensuring that nothing changes when the same playbook is run multiple times, keeping the state intact. 
To learn more, check out our <a href="https://spacelift.io/blog/ansible-tutorial">Ansible tutorial</a>.

Pip is the Python package installer. Ansible can be installed with pip, which is very straightforward to use and install any other Python package with. This also ensures that all Python dependencies are installed.

Ubuntu uses the APT package manager to install applications. Run the following commands to install Ansible on any Ubuntu Linux box:

Red Hat Enterprise Linux (RHEL) is a subscription-based product and provides Ansible as part of its software repository, ensuring enterprise-level stability and support.
To install Ansible on RHEL run:

CentOS utilizes the YUM package manager as well, and you can install Ansible directly from the EPEL repository:

MacOS uses a homebrew package manager, so it’s as simple as running the following command:

Windows is a bit more complex compared to all the Unix-like distributions. 
<h3>Can Ansible run on Windows?</h3>
There is no direct way to make a Windows machine into an Ansible control node. Ansible is designed to run on Unix-like operating systems such as Linux and MacOS. The main reason behind this is that Ansible depends on Python and certain Unix/Linux-specific functionalities like SSH for its operation, which does not natively integrate with Windows in the same manner. 
However, you can still have Windows machines as a managed node. Ansible is able to communicate with Windows-managed nodes using WinRM instead of SSH. Ansible supports managing Windows desktops OS 7, 8.1, 10, and 11, and for Windows Servers OS, 2008 R2, 2012, 2012 R2, 2016, 2019, 2022. You also need to have .NET 4.0, Powershell 3.0, or newer installed and have WinRM listener enabled. 
It&#8217;s also important to note that there are special Windows modules that need to be used against these Windows-managed nodes that are specific to Windows tasks instead of Linux tasks. 
If you have Windows-heavy environment, there are a few workarounds you can utilize in order to make a Windows machine into an Ansible control node. You can use: 
<h3>Windows Subsystem for Linux (WSL)</h3>
WSL allows you to run a Linux distribution directly on Windows, offering you to run any Linux application (such as Ansible) on your Windows machine, without the overhead of a traditional VM. You can install a Ubuntu Linux Distribution from the Microsoft Store for Windows Desktops, and for servers, you can install the distribution manually. 
Once you have the Linux Environment up and running on your WSL, you can then install Ansible within this Linux Environment. We will go over this in more detail in the coming steps. 
<h3>Docker for Windows</h3>
Docker allows you to run Docker containers on your Windows machine. The containers will run on a Linux distribution, and you can then install Ansible on it. This method is efficient and provides a high degree of portability and reproducibility for Ansible environments. 
<h3>Virtual Machine</h3>
You can utilize VMware Workstation, VMware Player, or Virtual Box on your Windows machine. You just need to install the OS on a virtual machine in one of the listed virtual platforms. This is listed as the third option since it tends to utilize a lot of system resources compared to WSL and Docker.
For this tutorial, we will cover installing Ansible on a Windows OS using WSL. At the time of this article, Ansible only supports Windows Server 2019 (manual) and 2022 WSL, Windows Desktop 10, and 11 to run as an Ansible Control node. If you want to install it on older versions of Windows Server, such as 2019, you will need to follow the steps described <a href="https://learn.microsoft.com/en-us/windows/wsl/install-manual" target="_blank" rel="nofollow noopener">here</a>. 
<h3>Installation Steps (Windows Server 2022 and Windows Desktop 10 &amp; 11) 
</h3>
<ol>
<li style="font-weight: 400;" aria-level="1">Open Powershell as Administrator and run the following to Enable WSL (Windows Subsystem for Linux). This, by default, will install Ubuntu as your Linux distribution.</li>
</ol>

<ol start="2">
<li>If you want to install a different Linux Distribution, you can run the following commands:</li>
</ol>

<ol start="3">
<li style="font-weight: 400;" aria-level="1">Once you have the Linux distribution installed, you will be prompted to create a user account and password.</li>
<li style="font-weight: 400;" aria-level="1">After this, you should now be able to run commands on your WSL Linux Box. 
In this example, we installed the Ubuntu Linux distribution and ran the following to install Ansible:</li>
</ol>

<ul>
<li><a href="https://spacelift.io/blog/using-terraform-and-ansible-together" target="_blank" rel="noopener">Using Terraform &amp; Ansible together</a></li>
<li><a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">How to better manage Ansible and overcome challenges</a></li>
<li><a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;44 Ansible Best Practices to Follow [Tips &amp; Tricks]&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">44 Ansible best practices to follow</a></li>
</ul>

<h3>1. Linux managed nodes</h3>
<h4>Prerequisites</h4>
In order to successfully test your Ansible setup, you need to have the following prerequisites: 
<ol>
<li style="font-weight: 400;" aria-level="1">One Ansible Control node, will serve as the central point from which we&#8217;ll manage and communicate with Ansible managed nodes via SSH. It can be your local machine or a dedicated server for running Ansible.</li>
</ol>
A non-root user with sudo rights and SSH keypair linked to this user on the control node. Create an SSH key pair on the control node using ssh-keygen if you haven’t done this by now.
<ol start="2">
<li>Ansible managed nodes configuration, these are the machines that the control node will automate and run playbooks on. You will also need the same non-root user with sudo rights on the managed nodes so the control node can authenticate properly</li>
</ol>
Add the public SSH key of the control node in the non-root user&#8217;s ~/.ssh/authorized_keys
<h4>1. Configure the Inventory file</h4>
Let’s start off by configuring the Inventory file. This is a directory for the managed nodes you&#8217;ll oversee using Ansible. It can include a range from a single to hundreds of servers and allows for organization into groups and subgroups.
To modify your default <a href="https://spacelift.io/blog/ansible-inventory" target="_blank" rel="noopener">Ansible inventory</a>, access the /etc/ansible/hosts file on your Ansible control node with your preferred text editor:

Note: While Ansible defaults to creating an inventory file at /etc/ansible/hosts, you have the flexibility to create inventory files and use the -i option with Ansible commands and playbooks to specify the file&#8217;s path. Adopting per-project inventories is recommended and can reduce the risk of executing a playbook on an incorrect set of servers. (See other <a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener">Ansible best practices</a>.)
Ansible&#8217;s default inventory file includes various examples as guidance for your setup. Below is an example that outlines a group named [ubuntu] containing two managed nodes with unique aliases: vm1 and vm2. Update the IP addresses to match those of your managed nodes.
The [all:vars] subgroup globally assigns the ansible_python_interpreter variable, ensuring all listed nodes use Python 3 (/usr/bin/python3), which supersedes Python 2.7 (/usr/bin/python) not found in recent Ubuntu distributions.

To save modifications, exit the editor by pressing ESC and typing :wq to Save and Quit.
<h4>2. Review your inventory setup</h4>
To review your inventory setup, run:

The output will display your server configuration as defined in the inventory file, resembling the provided example but tailored to your infrastructure.
Now, let’s jump into testing Ansible&#8217;s connectivity and command execution capabilities over SSH. Utilize the -u option to specify the remote system user (the non-root sudo user we created as part of the pre-requisites). If you don’t specify this option, Ansible attempts to connect using the control node&#8217;s current system user.
<h4>3. Perform a connectivity test</h4>
Run the following from your local machine or Ansible control node:

This command uses Ansible&#8217;s ping module to perform a connectivity test on all managed nodes in your default inventory. 

The ping module checks for:
<ul>
<li style="font-weight: 400;" aria-level="1">Accessibility of the nodes</li>
<li style="font-weight: 400;" aria-level="1">Validity of SSH credentials</li>
<li style="font-weight: 400;" aria-level="1">Nodes capability to execute Ansible modules via Python</li>
</ul>
A successful response will look like this:

If this is your first SSH connection attempt to these servers, you&#8217;ll need to confirm the authenticity of each managed node when prompted by typing yes and pressing ENTER.
Receiving a &#8220;pong&#8221; response indicates readiness for running Ansible commands and playbooks on the server.
<h3>Windows managed nodes</h3>
To successfully test your Ansible setup with Windows machines, you&#8217;ll need to ensure that your environment is properly configured to manage Windows as managed nodes. This involves setting up Windows Remote Management (WinRM), the primary protocol Ansible uses to communicate with Windows nodes. 
Below are the steps to prepare your Windows machines for Ansible management and to conduct a connectivity test using Ansible.
<h4>1. Prepare Windows managed nodes</h4>
First, ensure that WinRM is enabled on your Windows managed nodes. WinRM is enabled by default on Windows Server 2012/2016/2019, but if you&#8217;re working with Windows desktop versions or need to verify the configuration. You can enable WinRM by running the following command in PowerShell as an administrator:

<h4>2. Configure WinRM for Ansible</h4>
For Ansible to manage your Windows nodes securely, you&#8217;ll need to configure WinRM to use Basic authentication over HTTPS. While there are various ways to configure WinRM, you can use the ConfigureRemotingForAnsible.ps1 script, provided in the Ansible documentation. This script sets up WinRM with reasonable defaults for Ansible usage.
Download and run the script on each Windows managed node by executing the following command in PowerShell as an administrator:

<h4>3. Set up Windows firewall (optional)</h4>
 If you have a firewall enabled, ensure that it allows connections over the port WinRM is configured to use (default is 5986 for HTTPS).
<h4>4. Update your Ansible inventory file</h4>
Add your Windows managed nodes to your Ansible inventory file (/etc/ansible/hosts). You will specify the WinRM connection details here. For example:

Replace xx.xx.xx.xx with the IP address of your Windows managed node, and update the ansible_user and ansible_password with your Windows credentials.
<h4>5. Test connectivity to Windows managed nodes</h4>
After preparing your Windows managed nodes, you can test the Ansible setup by executing a simple connectivity test. This will verify that Ansible can communicate with the Windows nodes via WinRM.
Unlike Linux/Unix nodes, where the ping module is used, Ansible provides the win_ping module for testing connectivity with Windows nodes. 
Execute the following command from your Ansible control node:

This command targets all hosts in the [windows] group of your inventory file and uses the win_ping module to test connectivity.
Expected Outcome:
If the setup is correct, you&#8217;ll receive a SUCCESS message for each Windows managed node, indicating that Ansible can communicate with the Windows nodes via WinRM. The output will look similar to this:

Receiving a &#8220;pong&#8221; response confirms that your Windows managed nodes are correctly configured and ready for Ansible to run playbooks and tasks against them. This successful test ensures that you can proceed with automating your Windows infrastructure using Ansible.

Ansible&#8217;s design minimizes dependencies, requiring only Python and a few support libraries on both control nodes and managed nodes (which most Linux machines have pre-installed), streamlining its setup process.
You can easily install Ansible on a range of operating systems, including Ubuntu, RHEL, CentOS, MacOS, and Windows, regardless of your platform. Although Windows cannot directly serve as an Ansible control node due to its reliance on Python and SSH, the are some workarounds, like using Windows Subsystem for Linux (WSL), Docker, or a virtual machine to manage Windows as a managed node.

Download & Install Terraform on Windows, MacOS, Linux

How to Use Ansible Copy Module [Examples]

Atlantis: Terraform Pull Request Automation (Tutorial)

Learn how you can install Ansible using pip and on different operating systems like Ubuntu, RHEL, CentOs, Windows, and macOS.

352-install-ansible

How to Install Ansible

How to Install Ansible on Ubuntu, RHEL, macOS & CentOS

Ansible is an open-source automation tool that is used throughout DevOps practices to manage IT infrastructure. The platform is primarily known to simplify any repetitive tasks, configuration management, application deployment, orchestration, cloud provisioning, security and compliance tasks. Ansible is a configuration management tool and not a IaC (Infrastructure as Code) tool. The automation tasks are written in Ansible’s declarative language (YAML) throughout its playbooks. 
One of the key features of Ansible is the use of its various modules. <a href="https://spacelift.io/blog/ansible-modules" target="_blank" rel="noopener">Ansible modules</a> are units of code that can execute system commands or control system resources. They can be executed directly on remote hosts or through playbooks. Users can also write their own custom modules. 
 In this article, we will be focusing on the copy module.
We will cover:
<ol>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-copy#what-is-the-ansible-copy-module">What is the Ansible copy module?</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-copy#ansible-copy-module-examples">Ansible copy module examples</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-copy#ansible-copy-module-options">Ansible copy module options</a></li>
<li style="font-weight: 400;" aria-level="1"><a href="https://spacelift.io/blog/ansible-copy#ansible-copy-module-vs-templates">Ansible copy module vs templates</a></li>
</ol>

The Ansible Copy module allows you to copy files and recursive directories from a local machine (Ansible control node) to a remote machine. It&#8217;s mainly used to move files from one location to another, but it can also handle more complex situations like making sure files have not changed before moving, creating backups, and checking that files are correct after copying.
During the copying process, the Ansible copy module allows you to:
<ul>
<li>Back up the original file before it is copied over</li>
<li>Check if the file/directory already exists to prevent replacement (idempotency)</li>
<li>Assign the file/directory access to a specific user/group with restricted or open permissions</li>
<li>Move files within a remote machine</li>
<li>Perform in-line content changes on existing files in the remote host</li>
<li>Apply conditional logic</li>
</ul>
<h3>What is the difference between synchronize and copy in Ansible?</h3>
Other Ansible modules, such as the synchronize module, also perform file/directory transfers. The synchronize module uses the rsync protocol to transfer and sync multiple files or directories between the controller and remote machines. It is better for moving large sets of files and directories, while the copy module is more suitable for smaller sets of data.
<h3>What is the difference between copy and fetch module in Ansible?</h3>
Ansible fetch is another module that is similar to the copy module. This module is used to copy files from remote machines to your Ansible control node (remote to local). For example, if you have a config file on a remote server and you want to grab that file and move it over to your Ansible control node, you would use the fetch module. Refer to the <a href="https://docs.ansible.com/ansible/latest/collections/ansible/builtin/copy_module.html" target="_blank" rel="nofollow noopener">Ansible documentation</a> for more details.

Let&#8217;s look at some use-case examples.
<h3>Example 1: Copy files and directories from local to remote</h3>
The simplest use-case of the copy module is to perform a copy over from the Ansible control node to the remote machine. You will need to state the source location as a file location on the ansible control node, and the destination will be the specific location with the file name on your remote machine. 
By default, the copied over files will receive the permissions of <code>644 (-rw-r — r — )</code>, and the copied over directories will receive the permissions of <code>755 (drwxr-xr-x)</code>. This is based on your unmask value on your Linux system, which by default is <code>022</code>. If it was modified at some point, the default values for your files and directories might be different. 
Here is a simple example of using the Ansible copy module for copying over a text file to the remote host:

The first example below will copy over a directory along with all of its files and sub-directories to a non-existing directory on the remote machine. 
The second example will copy over just the contents in the source directory to an existing directory in the remote location. 
Note <code>become: true</code>, this is due to copying to a location that requires elevated sudo rights <code>(/opt/)</code>. Copying over to <code>/tmp</code> would not require sudo rights (<code>become: true</code>).

<h3>Example 2: Copy files and directories from local to remote with permissions</h3>
It is highly recommended and one of <a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener">Ansible’s best practices</a> to add Permissions using the copy function. This will ensure the same version of the file or directory with the exact same permissions is assigned across all your remote hosts. It is important to maintain uniformity in scripts, configuration files, and binary files across different environments. 
However, it’s just as important to make sure you don’t assign the wrong permissions to sensitive files as it can expose them to unauthorized access. 
For the most part, you will always use this format of the Ansible copy module:

<h3>Example 3: Move files within the remote machine</h3>
The Ansible copy module also allows you to move a file within a remote location from one directory to another. You just need to apply the parameter <code>remote_src: yes</code>. 
It’s important to note that this will only work for files and not directories. This step will also not work if <code>become</code> is not set to true, and it requires elevated permissions since you are moving over files from a source location that is not your Ansible control node.

<h3>Example 4: Copy inline content into a specific file</h3>
In certain situations, you don’t want to manage the files in your Ansible control node and would rather paste that specific content over to the file in the remote machine. Ansible’s copy inline content feature does just that.
Using the <code>content</code> parameter of the copy module, you can define the contents of a file inline within an <a href="https://spacelift.io/blog/ansible-playbooks" target="_blank" rel="noopener">Ansible playbook</a>. This can be very useful for creating or modifying files directly on the remote systems without the need to manage a separate file on the control node. This method also allows you to insert variables directly into the content you are copying over to the file in the remote machine. 
In the following example, I am using the copy content parameter to add <code>tomcat-users</code> to the <code>tomcat-users.xml</code> file in my remote machine using the specified variables. 
Note: In a real-world situation, you would not expose the secret in plain text on the file but would preferably use a secrets manager/vault. This is just for demonstration purposes.

<h3>Example 5: Copy with conditional statements</h3>
Like anything in code, logic and conditions are the key to a successful deployment. We will always encounter situations where we need the playbook run to fit our needs. We can accomplish that through Ansible’s conditional statements, which allow us to control whether specific tasks should get executed based on the conditions. 
For example, you might be concerned about specific files being deployed to the wrong environment. In that case, you can place conditions for specific environments (Dev, QA, UAT, Prod) for that copy job to be triggered. This is one of many methods to deliver files to specific environments.
The same concept applies to different OS versions, security conditions to be met for sensitive files, package dependencies, etc. Conditional statements are a powerful way to ensure that file transfers are efficient, secure, and relevant. You can maintain finer control over your infrastructure, reduce unnecessary data transfers, and ensure each machine receives exactly what it needs based on environment or state. This brings more flexibility to handle complex environments with diverse requirements. 
Below is an example of conditional copying using Ansible.

<h3>Example 6: Copy files with sudo permissions</h3>
I briefly went over this during the copying files over with the permissions section, but here, I will dive a little deeper and give more examples of when we should be using this. 
For the most part, all Linux systems are tightly locked down. To make any changes to the root directory, setting permissions on files/directories, modifying system files, placing scripts under root, etc., requires you to have elevated permissions. If you don&#8217;t, I highly recommend re-evaluating your Linux environment&#8217;s security structure. 
There are two ways to go about using sudo permissions in your playbooks.
<ul>
<li style="font-weight: 400;" aria-level="1">Assign <code>become:true</code> on the entire playbook &#8211; it is not recommended since you don&#8217;t always need elevated rights to perform certain Ansible tasks. </li>
<li style="font-weight: 400;" aria-level="1">Place the <code>become: true</code> on the specific task that requires elevated rights. This keeps things more secure and utilizes sudo rights when needed instead of blindly giving the entire playbook sudo rights. </li>
</ul>
The following example covers using sudo permissions on copying over a config file to the root directory:

<ul>
<li><a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">How to better manage Ansible and overcome challenges</a></li>
<li><a href="https://spacelift.io/blog/using-terraform-and-ansible-together" target="_blank" rel="noopener">Using Terraform and Ansible together</a></li>
<li><a href="https://spacelift.io/blog/ansible-best-practices" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;44 Ansible Best Practices to Follow [Tips &amp; Tricks]&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">44 Ansible best practices to follow</a></li>
</ul>

The Ansible Copy module has a few other parameters that should be used throughout your playbook to help you standardize your deployment and prevent any errors. 
<h3>1) Checksum</h3>
With Checksum, you can ensure idempotency to prevent redundant copy tasks from kicking off. This is useful if you want to prevent unnecessary network traffic and save more time during playbook run. You would specify the source path of the file on the Ansible control node, and Ansible will verify the local files checksum against the Checksum of the file at the destination path in the remote machine. Therefore, if the checksums match, Ansible will not copy the file. 
<h3>2) Backup</h3>
Backup is another parameter that is helpful if you want to prevent overwriting the existing file on the remote machine and capturing a backup of the file before the copy task is run. This is essential for preserving the previous state of a file and allowing an easy rollback if new configs cause any errors. 
<h3>3) Validate</h3>
The Validate parameter runs after the copy task is completed. This checks the integrity of the file you just copied over and makes sure it&#8217;s functional.
Below is an example of using all these options.

The Ansible Copy module provides many functionalities but does have some limitations. When we are running a copy task, it&#8217;s usually to copy a static file from one location to another. 
What do we do when we want to customize the file by injecting variables into it and copying it over? We can use the in-line content parameter to perform the variable injects. However, that also comes with limitations since the Ansible Copy content parameter is recommended for small amounts of data. Adding large amounts of text will make our playbooks overcrowded. 
This is when we can utilize the Ansible Template module, designed for transferring files that need to be dynamically modified or populated with variables before being copied over on the remote machine. 
The <a href="https://spacelift.io/blog/ansible-template" target="_blank" rel="noopener">Ansible Template</a> module uses Jinja2 templating language. You can copy your script or configuration file over to the .j2 template, and for variable substitution, replace all the areas of the template that need to be dynamic with variables. 
Now, you can pass in variables to any script or configuration file you want to copy to the remote machine. This is very useful when you have environment variables you want to pass into your script. 
Jinja templating can also be used for other scenarios outside of variable substitution, such as complex logic, loops, filters, and conditional statements. 
In the following example, I will go over a small Python script that needs to be environment-specific. I saved the script as a Jinja2 template and copied it over to the remote machine with the necessary variables. For more details, you can refer to the<a href="https://docs.ansible.com/ansible/latest/collections/ansible/builtin/template_module.html" target="_blank" rel="nofollow noopener"> Ansible documentation</a>.
Python script (this is saved as config.properties.py.j2 (jinja2 template)):

Ansible template module:

If you are looking to manage infrastructure as code, <a href="https://spacelift.io/" target="_blank" rel="noopener">Spacelift</a> is the way to go. It supports Git workflows, policy as code, programmatic configuration, context sharing, and many more great features. Spacelift lets you manage different infrastructure tools like Ansible, Terraform, Pulumi, AWS CloudFormation, and even Kubernetes from the same place and combine their <a href="https://docs.spacelift.io/concepts/stack/" target="_blank" rel="noopener">Stacks</a> with building workflows across tools.
If you want to learn more about Spacelift working with Ansible, check our <a href="https://docs.spacelift.io/vendors/ansible/" target="_blank" rel="noopener">documentation</a>, read our <a href="https://spacelift.io/blog/spacelift-ansible-integration-beta" target="_blank" rel="noopener">Ansible guide</a>, or <a href="https://spacelift.io/schedule-demo" target="_blank" rel="noopener">book a demo with one of our engineers</a>.

Ansible’s copy module is both flexible and powerful, making it a key tool in IT automation. It’s great for simple tasks like moving files from one location to another, but it can also handle more complex needs like making sure files have not changed before moving them using checksum, creating backups, and checking that files are correct and safe. This module is useful for different situations, whether it’s just copying over files as they are or ensuring that everything is secure and in the right place.

Spacelift helps you manage the complexities and compliance challenges of using Ansible. It brings with it a GitOps flow, so your infrastructure repository is synced with your Ansible Stacks, and pull requests show you a preview of what they’re planning to change. It also has an extensive selection of policies, which lets you automate compliance checks and build complex multi-stack workflows.

How to Use Ansible Vault to Keep Your Playbooks Secure

The copy module in Ansible and its use cases explained. See examples with files and directories on local and remote. Copy vs fetch vs sync.

Faisal Hashem

About the Spacelift blog

Ansible Loops : How To Use, Tutorial & Examples

Get the newsletter

Recent posts

How to Manage Kubernetes with Ansible [Tutorial]

How to Install Ansible on Ubuntu, RHEL, macOS & CentOS

How to Use Ansible Copy Module [Examples]

Share your data and download the guide