DEV Community: Enda

Invoking the Kubernetes API in Node.js

Enda — Thu, 01 Aug 2019 07:28:53 +0000

Life becomes just a little bit easier if you can invoke the Kubernetes API directly. That's why GoDaddy decided to make kubernetes-client, an easy to use Node.js client for Kubernetes.

It is listed as the officially supported Kubernetes client library for JavaScript. This is significant as it is has the backing of Kubernetes SIG API Machinery, which means it is kept up to date with changes to the Kubernetes API specification. It also means that your support requests and issues are much more likely to get a timely response.

Installing

Install with npm:

npm install kubernetes-client --save

Configuring

kubernetes-client generates a Kubernetes API client at runtime based on a Swagger/OpenAPI definition.

kubernetes-client will configure itself automatically by first trying to load configuration from the KUBECONFIG environment variable, then in ~/.kube/config. If it hasn't found anything yet it will then try to use an in-cluster service account, and eventually settle on a default proxy configuration as a last resort.

A simple configuration:

const { Client, KubeConfig } = require('kubernetes-client');
const Request = require('kubernetes-client/backends/request');

async function initKubeClient() {
  const kubeconfig = new KubeConfig();

  if (process.env.NODE_ENV === 'production') {
    kubeconfig.loadFromCluster();
  } else {
    kubeconfig.loadFromDefault();
  }

  const backend = new Request({ kubeconfig });
  const kubeclient = new Client({ backend });

  await kubeclient.loadSpec();

  return kubeclient;
}

Using

kubernetes-client maps path item objects to object chains ending in HTTP methods. So for example, api/v1/namespaces/myproject/configmaps maps to to .api.v1.namespaces('myproject').configmaps. This mapping logic can be used for all resources types.

You can refer to the Kubernetes API documentation to find the API endpoint for a particular resource.

Deployments

Let's learn how to interact with Deployments. I picked Deployments as an example as they are commonly used, and the same logic can be applied to all other resources.

Creating a deployment

You can create a deployment by making a POST request to the Kubernetes API.

const deploymentManifest = require('./nginx-deployment.json');

const createdDeployment = await kubeclient.apis.apps.v1.namespaces(namespace).deployments.post({ body: deploymentManifest });

console.log('NGINX Deployment created:', createdDeployment);

You can also verify that the deployment was created using kubectl.

$ kubectl get deployments
NAME               DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   1         1         1            0           1m

Modifying a deployment

To modify part of a resource you can send a PATCH request.

const labels = {
  metadata: {
    labels: {
      environment: 'DEVELOPMENT'
    }
  }
};

const modified = await kubeclient.apis.apps.v1.namespaces(namespace).deployments(deploymentManifest.metadata.name).patch({ body: labels });

console.log('Deployment modified:', modified.body.metadata);

Updating a deployment

By making a PUT request you can replace the entire resource.

const updated = await kubeclient.apis.apps.v1.namespaces(namespace).deployments(deploymentManifest.metadata.name).put({ body: deploymentManifest });

console.log('Deployment updated:', updated);

Fetching deployment(s)

Getting all deployments in a namespace.

const deployment = await kubeclient.apis.apps.v1.namespaces(namespace).deployments(deploymentManifest.metadata.name).get();

console.log('Deployment:', deployment);

Fetching a single deployment by in a namespace.

const deployments = await kubeclient.apis.apps.v1.namespaces(namespace).deployments.get();

console.log('Deployments:', deployments);

Getting all deployments in all namespaces.

const deployments = await kubeclient.apis.apps.v1.deployments.get();

console.log('Deployments (all namespaces):', deployments);

You can optionally specify a query string object qs to GET requests. For example, to filter on label selector.

const deployments = await kubeclient.apis.apps.v1.namespaces(namespace).deployments.get({ qs: { labelSelector: 'app=nginx'}});

console.log(deployments);

You can use the Kubernetes API documentation to see what other query parameters are available for a resource.

Deleting a deployment

Deployments can be deleted with DELETE.

const removed = await kubeclient.apis.apps.v1.namespaces(namespace).deployments(deploymentManifest.metadata.name).delete();

console.log('Deployment deleted:', removed);

Custom Resources

With kubernetes-client it is possible to extend the Kubernetes API with a CustomResourceDefinition.

In this example, I am creating a CustomResourceDefinition for GitHub accounts.

githubaccount-crd.json

{
  "kind": "CustomResourceDefinition",
  "spec": {
    "scope": "Namespaced",
    "version": "v1",
    "versions": [{
      "name": "v1",
      "served": true,
      "storage": true
    }],
    "group": "craicoverflow.github.io",
    "names": {
      "shortNames": [
        "ga"
      ],
      "kind": "GitHubAccount",
      "plural": "githubaccounts",
      "singular": "githubaccount"
    }
  },
  "apiVersion": "apiextensions.k8s.io/v1beta1",
  "metadata": {
    "name": "githubaccounts.craicoverflow.github.io"
  }
}

Creating a CustomResourceDefinition

const crd = require('./githubaccount-crd.json');

const createCRD = await kubeclient.apis['apiextensions.k8s.io'].v1beta1.customresourcedefinitions.post({ body: crd });

console.log('CustomResourceDefinition created:', createCRD);

You then need to add the endpoints for the new CustomResourceDefinition to kubeclient.

kubeclient.addCustomResourceDefinition(crd);

Creating a custom resource

Now that we have created the GitHubAccount CRD, we will be able to create a GitHubAccount custom resource.

githubaccount-cr.json

{
    "apiVersion": "craicoverflow.github.io/v1",
    "kind": "GitHubAccount",
    "metadata": {
        "name": "craicoverflow"
    },
    "spec": {
        "login": "craicoverflow",
        "blog": "https://endaphelan.me",
        "bio": "// TODO: Add a bio",
        "type": "User",
        "public_repos": "52"
    }
}

const customResource = require('./githubaccount-crd.json');

const createdAccount = await kubeclient.apis[crd.spec.group].v1.namespaces(namespace).githubaccounts.post({ body: customResource });

console.log('Created GitHubAccount:', createdAccount);

Fetching custom resource(s)

Fetching a GitHubAccount custom resource.

const githubAccount = await kubeclient.apis[crd.spec.group].v1.namespaces(namespace).githubaccounts(customResource.metadata.name).get();

console.log('GitHubAccount:', githubAccount);

Fetching all GitHubAccount custom resources in a namespace.

const allAccounts = await kubeclient.apis[crd.spec.group].v1.namespaces(namespace).githubaccounts.get();

console.log('GitHubAccountList:', allAccounts);

Deleting a custom resource

const deleteAccounts = await kubeclient.apis[crd.spec.group].v1.namespaces(namespace).githubaccounts(customResource.metadata.name).delete();

console.log('Deleted GitHubAccount:', deleteAccounts);

Deleting a CustomResourceDefinition

const deletedCRD = await kubeclient.apis['apiextensions.k8s.io'].v1beta1.customresourcedefinitions(crd.metadata.name).delete();

console.log('GitHubAccount CRD deleted:', deletedCRD);

Error handling

kubernetes-client outputs a HTTP error when a request fails. The following example emulates kubectl apply, by handling a 409 Conflict error when creating a deployment, and replacing the resource instead.

try {
  const createdDeployment = await kubeclient.apis.apps.v1.namespaces(namespace).deployments.post({ body: deploymentManifest });

  console.log('Deployment created:', createdDeployment);
} catch (err) {

  if (err.statusCode === 409) {
    const updatedDeployment = await kubeclient.apis.apps.v1.namespaces(namespace).deployments(deploymentManifest.metadata.name).put({ body: deploymentManifest });

    console.log('Updated updated:', updatedDeployment);
  }
}

Watching resources

You can use watch endpoints to stream events from resources. Common event types are ADDED, MODIFIED, DELETED, which signal a new or changed resource at that endpoint.

Watching deployments

const deploymentStream = await kubeclient.apis.apps.v1.watch.namespaces(namespace).deployments.getObjectStream();

deploymentStream.on('data', event => {
  if (event.type === 'ADDED') {
    console.log('Deployment created:', event.body);
  }
});

Watching custom resources

const githubAccountStream = await kubeclient.apis[crd.spec.group].v1.watch.namespaces(namespace).githubaccounts.getObjectStream();

githubAccountStream.on('data', event => {
  if (event.type === 'CLOSED') {
    console.log('GitHub account deleted:', event);
  }
});

To see the watch in action, create or update a GitHubAccount custom resource from your terminal and you will see the event stream output a new event in your Node.js application.

cat <<EOF | kubectl apply -n myproject -f -
apiVersion: craicoverflow.github.io/v1
kind: GitHubAccount
metadata:
  name: testuser
spec:
  bio: ''
  blog: https://example.com
  login: testuser
  public_repos: "100"
  type: User
EOF

Additional Resources

godaddy/kubernetes-client - the documentation for this library is brilliant. On top of that, there are lots of great examples.
craicoverflow/kubernetes-client-nodejs-example - a sample project containing all of the code from this guide.
Kubernetes Documentation - the official documentation for Kubernetes.

Enforcing Conventional Commits using Git hooks

Enda — Mon, 10 Jun 2019 21:39:24 +0000

I'm a huge fan of Conventional Commits. This relatively young specification provides a set of rules for creating an explicit, standardised commit history.

I've tried my best to follow the convention in all my projects. When I'm running low on caffeine I sometimes forget to follow the convention or let a typo slip past my eyes. To resolve this, I decided to create a dynamic commit-msg Git hook which automatically validates all of my commit messages, and prevents them from being committed if any of the conditions in the config file fail.

Creating the hook

Note: for the hook to read configuration values from a JSON file, you will need to install jq.

In your Git project, add a commit-msg hook in .git/hooks by renaming the sample script that is there already.

$ mv .git/hooks/commit-msg.sample .git/hooks/commit-msg

To start, let's read configuration values from a configuration file, which will later be added to the project's root.

config=commit-msg.config.json

# set variables
enabled=$(jq -r .enabled $config)
revert=$(jq -r .revert $config)
types=($(jq -r '.types[]' $config))
min_length=$(jq -r .length.min $config)
max_length=$(jq -r .length.max $config)

If the config file does not exist, or if the enabled property is false, we can exit the hook and skip validation.

if [[ ! -f $config || ! $enabled ]]; then
    exit 0
fi

Building a dynamic regex string

Let's start the regex with a hat symbol (^), which indicates the beginning of the string.

regexp="^("

If $revert is set to true, the commit message can optionally be prefixed with "revert:".

if $revert; then
    regexp="${regexp}revert: )?(\w+)("
fi

Let's get all of the allowed types from commit-msg.config.json.

for type in "${types[@]}"
do
    regexp="${regexp}$type|"
done

This next piece does two things. If an opening bracket comes immediately after the type, It must be closed and contain a scope. The second thing is that the type and/or scope must be followed with a colon symbol (:).

regexp="${regexp})(\(.+\))?: "

Here were are setting limits on the maximum and minimum length of the message immediately after the colon.

regexp="${regexp}.{$min_length,$max_length}$"

Validating the commit message

Now that the regex has been built, let's see some examples of how the commit message could look.

revert: docs: updated table of contents
feat(user): added constructor to model
fix: incorrect URL in link

Get the first line of the commit message:

msg=$(head -1 $1)

In the following statement, we are checking if the commit message passes the regex validation. If it fails, print out a custom error message and exit the script.

if [[ ! $msg =~ $regexp ]]; then
  echo -e "\n\e[1m\e[31m[INVALID COMMIT MESSAGE]"
  echo -e "------------------------\033[0m\e[0m"
  echo -e "\e[1mValid types:\e[0m \e[34m${types[@]}\033[0m"
  echo -e "\e[1mMax length (first line):\e[0m \e[34m$max_length\033[0m"
  echo -e "\e[1mMin length (first line):\e[0m \e[34m$min_length\033[0m\n"

  # exit with an error
  exit 1
fi

Configuration

The great thing about the Conventional Commit specification is its flexibility. You choose the rules that best suit your requirements. This flexibility is why I decided to make my hook configurable. Below is a sample configuration file.

Add it to the root of your project and make sure it matches the file name in the script; which in this case is commit-msg.config.json.

{
    "enabled": true,
    "revert": true,
    "length": {
        "min": 1,
        "max": 52
    },
    "types": [
        "build",
        "ci",
        "docs",
        "feat",
        "fix",
        "perf",
        "refactor",
        "style",
        "test",
        "chore"
    ]
}

Making your Git hook global

It is possible to create global Git hooks which are added to all of your projects on git init.

Enable Git templates:

git config --global init.templatedir '~/.git-templates'

Create a directory to save your global hooks:

mkdir -p ~/.git-templates/hooks

Create a commit-msg hook in ~/.git-templates/hooks/commit-msg, and make it executable:

touch ~/.git-templates/hooks/commit-msg
chmod u+x ~/.git-templates/hooks/commit-msg

You can repeat the steps from Making the hook and add them to the global commit-msg hook.

Sailr

If you'd rather not do any of the above, and want a ready-to-go solution, I've made this into its own project called Sailr.

Here's how you can install Sailr:

git clone https://github.com/craicoverflow/sailr
cd sailr
make install

Controlling component visibility with React Hooks

Enda — Mon, 22 Apr 2019 19:56:17 +0000

With the release of React 16.8, Hooks are the newest addition to the world's most popular front-end framework. Hooks give us access to state and other lifecycle events from functional components. Before now functional components were always stateless. To use state we had to write class components, which are more verbose and complex than their functional counterparts.

In this guide we are going to make a simple component which will remain hidden until a button is clicked. We will also set a timeout event to hide the component after a set duration.

For this we will use two hooks - useState and useEffect. I'll explain what they do when we go to implement them, but for now let's define the component and its props.

export const Alert = ({ visible, duration, onDurationEnd, children }) => {
    return children;
};

I've defined a functional component with four props.

visible (required) - This will be a boolean, either true or false. It controls the current visible state of the component.
duration (optional) - This is the duration is milliseconds that the component should display for before hiding again. If it is not set, the component will remain visible.
onDurationEnd (optional) - Callback function that executes after the duration has ended. Typically used reset the component's visibility to false from the parent component.
children (required) - This can be anything, from a single word to multiple components. children are added to the component as child elements.

State

useState allows us to use and set component state, which persists across renders. useState returns a pair, the current state value and a function for modifying it. Finally, useState takes a single argument which sets the initial value.

import React, { useState } from "react";

export const Alert = ({ visible, duration, onDurationEnd, children }) => {
    const [isVisible, setVisibility] = useState(null);

    return children;
};

Here we have set up a hook to control the visibility of the component. The initial state value is null as this will be overwritten almost immediately after render.

What I really like about useState is you can declare it multiple times in a single component.

const [isVisible, setVisibility] = useState(null);
// defining a second state variable
const [message, setMessage] = useState(null);

The benefit of this is that we can separate the control of different state values. In a class component, all state values are in a single object. So if you want to update one, you must also update the rest.

function setVisibility(visible) {
    this.setState({
        ...this.state,
        isVisible: visible
    });
}

Effect

useEffect lets us perform side effect functions from a functional component. A side effect is something which affects something outside of the function being executed, like state or a network request. Think of useEffect like componentDidMount, componentDidUpdate and componentWillUpdate combined. By using this hook, you tell React to execute the logic inside the hook after every render.

export const Alert = ({ visible, duration, onDurationEnd, children }) => {
    const [isVisible, setVisibility] = useState(null);

    useEffect(() => {
        setVisibility(visible); // update the state
    }, [visible]); // hook is only triggered when value changes

    return children;
};

So what does this do? After setting the initial state value, the useEffect hook is the next event to run. The hook overrides the initial value for isVisible to match the value acquired from the parent component's props.

The final argument in useEffect is an optional optimization. The effect will only re-run the if the value of visible changes, preventing unnecessary re-renders.

Once the useEffect hook has finished, we want to check the value of isVisible. If it's false, we don't want to render the component, so we return null.

if (!isVisible) return null;

If duration contains a value, we need to set a timeout which will reset the component's visibility once the duration has passed. If onDurationEnd is defined then the parent component expects the value for controlling this component's visibility to also be reset to false, once the timeout has complete.

if (duration) {
    setTimeout(() => {
        setVisibility(false);

        // pass `false` back to the parent to update its state
        if (onDurationEnd) {
            onDurationEnd(false);
        }
    }, duration);
}

Take a look at the finished component below. The introduction of React hooks has made developing components quicker, with fewer lifecyle events to worry about. The file itself is reduced by a number of lines versus a class component that does the same thing.

import React, { useState, useEffect } from "react";
import PropTypes from "prop-types";

/**
 * Customisable alert component that remains hidden until called.
 *
 * @param {boolean} props.visible - The current visibility of the component.
 * @param {number} [props.duration] - The time in milliseconds to display the component for. If not set, the component will stay visible.
 * @param {func} onDurationEnd - Set visible state of component from parent.
 * @param {*} props.children - Child components.
 */
export const Alert = ({ visible, duration, onDurationEnd, children }) => {
    const [isVisible, setVisibility] = useState(null);

    useEffect(() => {
        setVisibility(visible);
    }, [visible]);

    if (!isVisible) return null;

    if (duration) {
        setTimeout(() => {
            setVisibility(false);

            if (onDurationEnd) {
                onDurationEnd(false);
            }
        }, duration);
    }

    return children;
};

Alert.propTypes = {
    visible: PropTypes.bool.isRequired,
    timeout: PropTypes.number,
    children: PropTypes.node.isRequired
};

Check out a live demo or the code from this tutorial on GitHub.

If you like this post, check out the original and subscribe for more!

A no-nonsense guide to environment variables in Go

Enda — Sat, 02 Mar 2019 18:05:42 +0000

Environment variables are the best way to set configuration values for your software application as they can be defined at system-level, independently of the software. This is one of the principles of the Twelve-Factor App methodology and enables applications to be built with portability.

Using environment variables

All you need to interact with environment variables is the standard os package. Here is
an example of how you can access the system PATH environment variable.

It’s equally easy to set environment variables:

Loading environment variables from a .env file

It is not always practical to set environment variables on development machines
where multiple projects are running.

godotenv is a Go port of the Ruby
dotenv library. This allows you to define
your application’s environment variables in a .env file.

To install the package run:



$ go get github.com/joho/godotenv

Add your configuration values to a .env file at the root of your project:

GITHUB_USERNAME=craicoverflow
GITHUB_API_KEY=TCtQrZizM1xeo1v92lsVfLOHDsF7TfT5lMvwSno

Then you can use these values in your application:

It’s important to note that if an environment variable is already defined in the
system, then Go will prefer use that instead of the value in .env.

Wrapping environment variables in a configuration package

It's all well and good accessing environment variables directly like this, but having to maintain that doesn't seem fun, does it? Every value is a string - and imagine having to update every reference when an environment key is modified!

To deal with this, let’s create a configuration package to access environment variables in a much
more centralized and maintainable way.

Here is a simple config package which will return configuration values in a
Config struct. We have the option to define a default value, so when an
environment variable does not exist this will be used instead.

Next, we should add different types to the Config struct. The current implementation can only handle string types, which isn’t very practical for larger applications.

Let's add functions to handle bool, slice and integer types.

Update your .env file with these environment variables.

GITHUB_USERNAME=craicoverflow
GITHUB_API_KEY=TCtQrZizM1xeo1v92lsVfLOHDsF7TfT5lMvwSno
MAX_USERS=10
USER_ROLES=admin,super_admin,guest
DEBUG_MODE=false

And now you can access these values from the rest of your application:

And there you have it

There are several libraries out there that claim to offer a configuration
“solution” for your Go application. But is it really a solution when it’s just
as easy to make one yourself?

How do you manage configuration in your Go applications?

Did you enjoy this post? Be sure to check out more like it at https://endaphelan.me.

Committing Better Go Code with Static Analysis and Git Hooks

Enda — Thu, 07 Feb 2019 22:31:56 +0000

I've been using Go for a while now and there are three static analysis tools (linters) that I use daily. There are dozens more that I could be using, but I don't think it's wise to become too dependent on these tools (most of which are unofficial) to do your job for you. Eventually they will become a nightmare to track, maintain and they may eventually become unmaintained or unsupported.

Gofmt

Gofmt is an official tool for formatting Go code that has come as part of the language since 2013.

It's as simple as this to format a file:

$ go fmt main.go

Or you can target an entire package:

$ go fmt ./pkg/models

To format all packages (excluding vendor) beneath the current directory:

$ go fmt $(go list ./... | grep -v /vendor/)

errcheck

In the maker's own words, errcheck "checks that you checked errors". In other words, it will scan your code and tell you if there are any errors. This can be useful for those times you sillily forget to run your application after making a small change.

To check errors in a package:

$ errcheck ./pkg/models

Or to scan all packages (excluding vendor) beneath the current directory:

errcheck $(go list ./... | grep -v /vendor/)

Vet

Vet is another official static analysis tool in Go. Vet inspects the source code for suspicious constructs, such as Printf calls whose arguments do not align with the format string.

It's execution is very similar to that of Gofmt.

Vetting a single file:

$ go vet main.go

Vetting an entire package:

$ go vet ./pkg/models

Vetting all packages (excluding vendor) beneath the current directory:

$ go fmt $(go list ./... | grep -v /vendor/)

Automating These Tools With Git Hooks

Git hooks are a great way to automate these repetitive tasks and ensure you don't commit or push any incomplete code. The hooks are all stored in the .git/hooks subdirectory of your Git project and will automatically execute on or after a pre-defined list of Git events.

For this, we are going to bind to the pre-commit hook as we only want our script to check the files before committing them to Git.

Create a new file in .git/hooks called pre-commit and open it in your favourite editor. Make it executable by running chmod +x .git/hooks/pre-commit from the terminal.

First, let's store the list of files in our project into a variable called FILES:

FILES=$(go list ./...  | grep -v /vendor/)

Add Gofmt next to format your code:

go fmt ${FILES}

Once formatted, the most important thing we need to check for is if there are any errors. If there are we can exit the script and prevent the commit.

{
    errcheck -ignoretests ${FILES}
} || {
    exitStatus=$?

    if [ $exitStatus ]; then
        printf "\nErrors found in your code, please fix them and try again."
        exit 1
    fi
}

If the code is error-free, the next thing we should check is if there are any suspicious constructs.

{
    go vet ${FILES}
} || {
    exitStatus=$?

    if [ $exitStatus ]; then
        printf "\nIssues found in your code, please fix them and try again."
        exit 1
    fi
}

Here's the complete pre-commit hook. Add this to your project today and start committing better Go code.

How to enable OpenShift service catalog components in Minishift

Enda — Mon, 17 Dec 2018 21:03:07 +0000

Original post: https://endaphelan.me/guides/openshift/how-to-enable-openshift-components-in-minishift

Note: This only works with OpenShift version >= 3.10.x

There are two ways to enable OpenShift service catalog components in Minishift.

The recommended method is to run the minishift openshift component add command when your cluster is already running:

$ minishift openshift component add service-catalog
$ minishift openshift component add automation-service-broker
$ minishift openshift component add template-service-broker

You can also enable components during minishift start. This is still one of Minishift's experimental features, so you will need to set the environment variable MINISHIFT_ENABLE_EXPERIMENTAL in order for it to work:

$ export MINISHIFT_ENABLE_EXPERIMENTAL=y

Then run minishift start with extra flags to enable catalog components:

$ minishift start --extra-clusterup-flags "--enable=*,service-catalog,automation-service-broker,template-service-broker"

How to Install Ansible

Enda — Tue, 20 Nov 2018 23:34:12 +0000

Original post: https://endaphelan.me/programming/guides/ansible/installing-ansible

Ansible is compatible with any machine running Linux or MacOS (sorry Windows users!). Before proceeding with this guide it is a requirement that you have Python 2 (version 2.7+) or Python 3 (version 3.5+) installed.

The simplest way to install Ansible is by using the default package manager for your operating system.

Fedora

$ sudo dnf install ansible

RHEL/CentOS

$ sudo yum install ansible

Ubuntu

Add the PPA to your system:

$ sudo apt-get install software-properties-common
$ sudo apt-add-repository --yes --update ppa:ansible/ansible

Install Ansible:

$ sudo apt-get install ansible

Debian

Add the PPA to your system:

$ echo "deb http://ppa.launchpad.net/ansible/ansible/ubuntu trusty main" >> /etc/apt/sources.list

Now add the PPA to a list of trusted sources and update the system:

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 93C4A3FD7BB9C367
$ sudo apt-get update

Install Ansible:

$ sudo apt-get install ansible

MacOS

See Installing with pip below for instructions on how to install Ansible on MacOS.

Arch Linux

$ sudo pacman -S ansible

Installing with pip

pip is Python's package manager. We will need to install in order to use it.

MacOS

$ sudo easy_install pip

Fedora

Python 2.x

$ sudo dnf upgrade python-setuptools
$ sudo dnf install python-pip python-wheel

Python 3.x

$ sudo dnf install python3 python3-wheel

RHEL/CentOS

Python 2.x

$ sudo yum upgrade python-setuptools
$ sudo yum install python-pip python-wheel

Python 3.x

sudo yum install python3 python3-wheel

Ubuntu

Python 2.x

$ sudo apt-get install python-pip

Python 3.x

$ sudo apt-get install python3-pip

Arch Linux

Python 2.x

$ sudo pacman -S python2-pip

Python 3.x

$ sudo pacman -S python-pip

Once pip is installed you can install Ansible:

$ pip install ansible --user

Installing a Specific Version of Ansible

If you are installing the latest version of Ansible then it is recommended to use the default package manager for your operating system.

Sometimes we need to install older versions. For this we can also use pip:

$ pip install ansible==2.6 --user

Installing Multiple Versions

We can use virtualenv to create and manage multiple isolated Python environments. This can be installed using pip:

$ pip install virtualenv --user

Creating a virtual environment for Ansible 2.6:

$ virtualenv ansible2.6

Activate the ansible2.6 environment:

$ source ansible2.6/bin/activate

Now install Ansible 2.6 in the virtual environment:

$ pip install ansible==2.6

To deactivate an environment just run deactivate:

$ deactivate

We can repeat the steps above to create another virtual environment for Ansible 2.7:

$ virtualenv ansible2.7
$ source ansible2.7/bin/activate
$ pip install ansible==2.7

How to change the theme in your Jekyll application

Enda — Mon, 12 Nov 2018 20:50:56 +0000

Originally posted at https://endaphelan.me/technology/programming/changing-theme-in-jekyll-application.

Follow these steps and you will be able to change the theme in your Jekyll application.

Create a new orphan branch and ensure it is empty.

git checkout --orphan newtheme
git rm -rf .
git clean -dfx

Now let's add the theme's repository as an upstream remote and pull the files into our branch. I am using Moon theme by Taylan Tatlı.

git remote add upstream https://github.com/TaylanTatli/Moon.git
git fetch upstream
git pull upstream master

Install Gem dependencies and run your application to see if the previous steps were successful.

bundle install
jekyll serve

All okay so far? Good. Now it's time to merge your blog posts, configuration and other custom files.

This will bring in your posts from master:

git checkout master -- _posts

You can safely merge these files and folders:

README.md and other custom Markdown files.
_posts directory.
_drafts directory.
CNAME file.
Favicon files.
Other custom files and directories such as pictures.

Some old files will conflict with ones from your new theme. The safest thing to do here is to copy the file to a new name and merge it manually.

git show master:_config.yml > _config.yml.old

Accidentally overwritten a theme file? No problem:

git checkout upstream/master -- index.md

I recommend manually merging these files:

_config.yml
Gemfile

Now replace master with the newtheme branch:

git checkout newtheme
git merge -s ours master --allow-unrelated-histories
git checkout master
git merge

Run the application again to see if your changes have come through:

jekyll serve

Push your changes:

git push

Leave no evidence of the crime by deleting the newtheme branch.

git branch -d newtheme

Credits

This solution is adapted from Daniel Pelsmaekerwith's answer on StackOverflow to work with the latest versions of Git, Bundler and Jekyll.