Science and technology

A knowledge-centric strategy to patching techniques with Ansible

When you are patching Linux machines as of late, I might forgive you for asking, “How hard can it be?” Sure, a yum replace -y will type it for you in a flash.

But for these of us working with greater than a handful of machines, it isn’t that easy. Sometimes an replace can create unintended penalties throughout many machines, and also you’re left questioning the right way to put issues again the best way they had been. Or you would possibly suppose, “Should I have applied the critical patch on its own and saved myself a lot of pain?”

Faced with these kinds of challenges previously led me to construct a strategy to cherry-pick the updates wanted and automate their software.

A versatile thought

Here’s an summary of the method:

This system does not allow machines to have direct entry to vendor patches. Instead, they’re selectively subscribed to repositories. Repositories comprise solely the patches which can be required––though I might encourage you to present this cautious consideration so you do not find yourself with a proliferation (one other administration overhead you will not thank your self for creating).

Now patching a machine comes all the way down to 1) The repositories it is subscribed to and a pair of) Getting the “thumbs up” to patch. By utilizing variables to manage each subscription and permission to patch, we needn’t tamper with the logic (the performs); we solely want to change the information.

Here is an example Ansible role that fulfills each necessities. It manages repository subscriptions and has a easy variable that controls working the patch command.

# duties file for patching

- title
: Include OS model particular variations
: "- ansible_distribution_major_version .yml"

- title
: Ensure Yum repositories are configured
: template.repo.j2
: "/etc/yum.repos.d/ item.label .repo"
: root
: root
: 0644
: patching_repos is outlined
: " patching_repos "
: patching-clean-metadata

- meta
: flush_handlers

- title
: Ensure OS shipped yum repo configs are absent
: "/etc/yum.repos.d/ patching_default_repo_def "
: absent

# add flexibility of repos right here
- title
: Patch this host
: 'yum replace -y'
: false
: patchme|bool
: outcome
: "'No packages marked for update' not in result.stdout"


In our fictitious, massive, globally dispersed setting (of 4 hosts), now we have:

  • Two net servers
  • Two database servers
  • An software comprising one among every server sort

OK, so this variety of machines is not “enterprise-scale,” however take away the counts and picture the setting as a number of, tiered, geographically dispersed purposes. We need to patch components of the stack throughout server varieties, software stacks, geographies, or the entire property.

Using solely adjustments to variables, can we obtain that flexibility? Sort of. Ansible’s default behavior for hashes is to overwrite. In our instance, the patching_repos variable for the db1 and web1 hosts are overwritten due to their later prevalence in our stock. Hmm, a little bit of a pickle. There are two methods to handle this:

  1. Multiple stock information
  2. Change the variable behavior

I selected primary as a result of it maintains readability. Once you begin merging variables, it is onerous to search out the place a hash seems and the way it’s put collectively. Using the default conduct maintains readability, and it is the tactic I might encourage you to stay with to your personal sanity.

Get on with it then

Let’s run the play, focusing solely on the database servers.

Did you discover the ultimate step—Patch this host—says skipping? That’s as a result of we did not set the controlling variable to do the patching. What now we have performed is ready up the repository subscriptions to be prepared.

So let’s run the play once more, limiting it to the online servers and inform it to do the patching. I ran this instance with verbose output so you’ll be able to see the yum updates taking place.

Patching an software stack requires one other stock file, as talked about above. Let’s rerun the play.

Patching hosts within the European geography is identical state of affairs as the appliance stack, so one other stock file is required.

Now that each one the repository subscriptions are configured, let’s simply patch the entire property. Note the app1 and emea teams do not want the stock right here––they had been solely getting used to separate the repository definition and setup. Now, yum replace -y patches every little thing. If you did not need to seize these repositories, they may very well be configured as enabled=zero.


The flexibility comes from how we group our hosts. Because of default hash conduct, we want to consider overlaps—the simplest method, to my thoughts not less than, is with separate inventories.

With regard to repository setup, I am positive you’ve got already stated to your self, “Ah, but the cherry-picking isn’t that simple!” There is further overhead on this mannequin to obtain patches, take a look at that they work collectively, and bundle them with dependencies in a repository. With complementary instruments, you possibly can automate the method, and in a large-scale setting, you’d need to.

Part of me is drawn to simply making use of full patch units as a less complicated and simpler strategy to go; skip the cherry-picking half and apply a full set of patches to a “standard build.” I’ve seen this strategy utilized to each Unix and Windows estates with enforced quarterly updates.

I’d be thinking about listening to your experiences of patching regimes, and the strategy proposed right here, within the feedback under or via Twitter.

Most Popular features the latest multimedia technologies, from live video streaming to audio packages to searchable archives of news features and background information. The site is updated continuously throughout the day.

Copyright © 2017 Breaking Express, Green Media Corporation

To Top