A version control system is crucial in working with web-based repositories, and Git is the most popular one in the world today. But no one wants to get stuck in managing repositories manually all day. So how do you automate managing repositories? Before scouring the internet for answers, why not try the Git Ansible module?
Ansible Git module allows you to work with Git repositories efficiently. And in this tutorial, you’ll learn how the Git Ansible module lets you clone or perform checkouts in different folders for your GitHub repositories.
Prerequisites
This tutorial comprises step-by-step instructions. If you’d like to follow along, be sure you have the following in place:
- An Ansible controller host – This tutorial uses Ansible v2.11.7 on an Ubuntu 20.04.3 LTS machine.
- A remote Linux computer to test out the Git Ansible module. This tutorial uses Ubuntu 20.04.3 LTS as the remote node.
- A GitHub account with one private and one public repository created in GitHub containing a hello.py Python file.
- SSH key generated on the Ansible Node. The private key will remain on the Ansible remote node, but you’ll add the public key on GitHub for authentication.
- An inventory file set up and one or more hosts already configured to run Ansible command and playbooks on. The remote Linux computer is called myserver, and this tutorial uses an inventory group called web.
- Python v3.6 or later installed on your Ansible controller host and the remote node machine. This tutorial will be using Python v3.8.10 on a ubuntu machine.
Cloning Git Repository Using Ansible Ad Hoc Commands
Perhaps you’re looking into quickly cloning one repository on a remote host. If so, running ad hoc commands will suffice. Kick off this tutorial using the Git Ansible module to clone a repository with ad-hoc commands. Ad hoc commands are a quick and efficient way to run a single command on a remote host.
Log onto your Ansible controller and run the below ansible command to connect (-m ansible.builtin.git) to the host (web).
The command passes an argument (-a) that tells Ansible to clone (clone=yes) the content from the repository (repo) to a destination (dest=/tmp/clone_test) on the remote host.
From this point throughout the tutorial, make sure to replace the repository URL https://github.com/ShankyTheBlogger/ATA-testing.git in each code with your own.
ansible web -m ansible.builtin.git -a "repo=https://github.com/ShankyTheBlogger/ATA-testing.git clone=yes dest=/tmp/clone_test"Once the command completes, you’ll see a CHANGED message, as shown below, that confirms Ansible successfully cloned the repository on the remote host.
Cloning Public and Private Git Repositories with Ansible Playbook
Running Git commands on the Git repository may be okay with an ad-hoc command. Still, executing multiple commands on a Git repository can be challenging. Instead of using ad-hoc commands, take advantage of the Ansible Git module with a playbook using the ansible-playbook command.
Assuming you’re already logged into the Ansible controller host:
1. Run the following commands to create a directory called ~/ansible_git_module. This directory will contain the playbook and all the required configuration files that you’ll use to invoke the Ansible Git module.
mkdir ~/ansible_git_module
cd ~/ansible_git_module2. Next, open your favorite text editor, create a file called main.yml in the ~/ansible_git_module directory, and copy/paste the following YAML playbook contents.
The playbook below performs various tasks with the Git repository, such as cloning the public and private repository and confirming if the Git repository has been successfully cloned.
---
- name: Ansible GIT module demo
hosts: web
# Defining the remote server where the ansible git module will manage the objects
remote_user: ubuntu # Using Remote user as ubuntu
tasks:
# Clones the public repository in the clone folder inside the opt directory.
- name: Clone a PUBLIC repo
ansible.builtin.git:
repo: https://github.com/ShankyTheBlogger/ATA-testing.git
dest: /opt/clone
separate_git_dir: /opt/clone.git
clone: yes
update: yes
# Clones the private repository in the private_clone folder inside the *opt* directory.
- name: Clone a PRIVATE repo
ansible.builtin.git:
repo: [email protected]:ShankyTheBlogger/Privaterepo.git
dest: /opt/private_clone
clone: yes
# accept_hostkey: no
key_file: /home/ubuntu/.ssh/id_rsa
version: main
# Confirms if the public repository was successfully cloned in the specified folder.
- name: Confirming if the Git repository has been succesfully cloned locally
ansible.builtin.git:
repo: https://github.com/ShankyTheBlogger/ATA-testing.git
dest: /opt/clone
clone: no
update: no
- name: Clone a repo with separate git directory Git to separate from current working tree.
ansible.builtin.git:
repo: https://github.com/ShankyTheBlogger/ATA-testing.git
dest: /opt/different-directory.
separate_git_dir: /opt/different-directory.git3. Run the command below to invoke the playbook (main.yml). The playbook then executes the tasks (to clone, checkout repositories, and so on) on the remote node.
ansible-playbook main.ymlBelow, you can see that some tasks show a changed status, which indicates the remote host wasn’t in the proper state and was modified to run the command. In contrast, the tasks that show an ok status don’t require any changes.
4. Now run each command below to list all files in the opt directory. This command lets you verify if you’ve properly cloned the Git repositories and made a checkout in the specified folders defined in the main.yml playbook.
cd /opt
ls -lhAfter running the commands, you’ll see an output similar to the one below. The output confirms the successful cloned Git repositories within the specified opt directory on the remote node.
Cloning a Different Branch Using SSH Git URL
Cloning Git repository using HTTP GitHub URL works fine, but is it secure? There is a way to connect your machine with GitHub and clone the repository securely, which is by using SSH Git URL.
Using the same Ansible Controller host, create the playbook named diff_branch.yaml and copy/paste the code below. The below playbook clones branch2 from the specified repository ([email protected]:ShankyTheBlogger/ATA-testing.git) as defined inside the version.
---
- name: Ansible GIT module demo
hosts: web
# Defining the remote server where the ansible git module will manage the objects
remote_user: ubuntu # Using Remote user as ubuntu
tasks:
- name: Clone branch2 from ATA-tetsing repository
ansible.builtin.git:
repo: [email protected]:ShankyTheBlogger/ATA-testing.git
dest: /tmp/branch2-ata-testing
clone: yes
version: branch2Now execute the playbook, which clones the branch2 branch.
ansibile-playbook diff_branch.yaml
Switching Branches with Git Checkout in Ansible Playbook
Having one branch if you’re the only one working on a small project is all good. But what if you’re working with other developers? You’ll need a way to switch between branches. Ansible Git module together with Git checkout is the solution!
Git checkout is to check out the desired status of your repositories, such as branches or particular files.
Create the Ansible playbook named checkout.yaml and copy/paste the code below. The below playbook will checkout the repository in the opt directory.
---
- name: Ansible checkout demo
hosts: web
remote_user: ubuntu # Using Remote user as ubuntu
tasks:
# Checkouts the repository in the opt directory
- name: Git checkout
ansible.builtin.git:
repo: 'https://github.com/ShankyTheBlogger/ATA-testing.git'
dest: /opt/checkout
# Confirms if the repository is checked out successfully in the opt directory
- name: Confirming if the Git repository has been succesfully checkout
ansible.builtin.git:
repo: https://github.com/ShankyTheBlogger/ATA-testing.git
dest: /opt/checkout
update: noNow run the ls command below to list all files inside the opt directory.
ls -lhAs you can see below, the repository is checked out successfully in the opt directory.
Archiving a GitHub Repository
Perhaps you prefer to make the repository read-only to everyone. If so, archiving a repository is a good solution. But bear in mind that you can also unarchive your repository anytime. Archiving a repository saves all your repository’s resources to a ZIP file in a specified location.
Before archiving your repository, make sure you’ve changed its settings and consider closing all open issues and pull requests.
1. Create the Ansible playbook named archive.yaml and copy/paste the code below. The below playbook archives the specified repository to the tmp/archive directory.
---
- name: Ansible checkout demo
hosts: web
remote_user: ubuntu # Using Remote user as ubuntu
tasks:
- name: Create git archive from repository containing the tree structure for the source.
ansible.builtin.git:
repo: https://github.com/ShankyTheBlogger/ATA-testing.git
dest: /tmp/archive
archive: /tmp/archive/archive.zip2. Now execute the playbook (archive.yaml), which archives a specific repository. ansible-playbook archive.yaml
ansible-playbook archive.yaml
3. Finally, change the directory to tmp/archive and run the ls command to verify if Ansible successfully archived the repository.
lsAs you can see below, the archived repository exists in the tmp/archive directory.
Conclusion
In this tutorial, you’ve learned that the Git Ansible module is a great way to manage your Git repositories effectively using single Ansible command on remote hosts. With the Git Ansible module, you get to work with your Git repositories quickly and remotely.
Now, why not add more control on how you manage your repositories? Learn how to work with Ansible when and other conditionals.
