How to Write a DevOps Handover Document

A DevOps Handover document template to help a person leaving a project pass on the work done to another engineer, so it is continued, the work is around the Ansible playbook, for ci/cd automation, Jenkins pipeline and GitLab repository..

                          ##### BEGINNING OF  DOCUMENT TEMPLATE #########

DevOps Handover Document

Project Overview

Provide a brief overview of the project, its objectives, and its key components.

• Project Name:
• Project Description:
• Key Stakeholders:
• Project Timeline:
• Current Status:

Ansible Playbook

Overview

Provide an overview of the Ansible playbook used in the project.

• Purpose: Describe the purpose of the playbook.
• Main Playbooks and Roles: List the primary playbooks and roles, their locations, and their functions.
• Dependencies: Outline any dependencies or prerequisites for running the playbooks.

Directory Structure

├── ansible/
│   ├── playbooks/
│   │   ├── main_playbook.yml
│   │   └── other_playbooks.yml
│   ├── roles/
│   │   ├── role1/
│   │   └── role2/
│   ├── inventory/
│   │   ├── production
│   │   └── staging
│   └── ansible.cfg

• Playbooks: Detailed description of key playbooks and their functions.
• Roles: Detailed description of key roles and their tasks.
• Inventory: Description of the inventory files and their purpose.
• Configuration: Any special configurations in ansible.cfg.

Running Playbooks

Provide step-by-step instructions for running the playbooks.

1. Setup Environment:

   bash
   ansible-playbook -i inventory/production main_playbook.yml
   

2. Common Commands:
   • Command for running a specific playbook.
   • Command for running playbooks in staging/production environments.
   • Command for checking the playbook syntax.
   • Any other relevant commands.

CI/CD Automation

Jenkins Pipeline

Overview

Provide an overview of the Jenkins pipeline configuration.

• Purpose: Describe the pipeline’s role in the project.
• Pipeline Stages: List and describe each stage of the pipeline.

Configuration

• Jenkinsfile Location:
• Pipeline Script: Provide a snippet or full script of the Jenkinsfile if possible.
• Plugins: List the Jenkins plugins used and their purposes.

Common Tasks

• Triggering Builds: How to manually trigger builds.
• Monitoring Builds: How to monitor build status and logs.
• Debugging Issues: Steps to debug common issues.

GitLab Repository

Overview

Provide an overview of the GitLab repository setup.

• Repository URL:
• Branches: List and describe the purpose of key branches (e.g., main, develop, feature/*, hotfix/*).
• Branching Strategy: Explain the branching strategy used in the project.
• Merge Requests: Outline the process for creating and reviewing merge requests.

Repository Structure

bash
├── .gitlab/
│   ├── ci/
│   │   ├── stages/
│   │   ├── jobs/
│   │   └── scripts/
├── src/
│   ├── main/
│   └── test/
├── docs/
└── README.md

• Key Directories: Description of key directories and their contents.
• CI Configuration: Details of GitLab CI configuration (.gitlab-ci.yml).

Common Tasks

• Cloning the Repository:

  bash
  git clone <repository_url>
  

• Working with Branches:
  • Creating a new branch.
  • Merging branches.
• CI/CD Pipelines:
  • How to trigger pipelines.
  • Monitoring pipeline status.
  • Debugging failed pipelines.

Contacts and Resources

Provide a list of key contacts and resources for further assistance.

• Project Manager: Name, email, phone number.
• Technical Lead: Name, email, phone number.
• Relevant Documentation: Links to any additional documentation or resources.
• Access Credentials: Securely provide any necessary credentials or access details.

Additional Notes

Any additional notes, tips, or important information to be aware of.

---

Prepared by: [Your Name]
Date: [Date]

                                   ##### END OF  DOCUMENT TEMPLATE #########

How to Reboot RedHat Server 9 using Jenkins and Ansible Playbooks

 In order for you to automate the process of Reboot RedHat Servers with Jenkins and Ansible Playbooks.

You have to create a Jenkins pipeline for an application that involves the following steps: rebooting a Red Hat Server 9 using Ansible Playbooks, building, testing, scanning with SonarQube and Fortify, and storing the artifact in JFrog Artifactory. 

Below are the detailed steps along with the required Jenkinsfile, Ansible playbook, and information on the necessary credentials.

Prerequisites

1. Jenkins Setup:

   • Jenkins should be installed and configured.
   • Plugins: Ansible, SonarQube Scanner, Fortify, JFrog Artifactory.

2. Credentials:

   • Ansible: SSH Key for Red Hat Server.
   • SonarQube: API Token.
   • Fortify: API Token.
   • JFrog Artifactory: Username and API Key.

3. Tools:

   • Ansible installed and configured on Jenkins.
   • SonarQube and Fortify servers accessible from Jenkins.
   • JFrog Artifactory accessible from Jenkins.

Jenkins Pipeline Script (Jenkinsfile)

groovy
pipeline {
    agent any

    environment {
        ANSIBLE_PLAYBOOK = 'reboot-server.yml'
        ANSIBLE_INVENTORY = 'hosts'
        SONARQUBE_SERVER = 'sonarqube.example.com'
        SONARQUBE_TOKEN = credentials('sonarqube-token')
        FORTIFY_SERVER = 'fortify.example.com'
        FORTIFY_TOKEN = credentials('fortify-token')
        ARTIFACTORY_SERVER = 'artifactory.example.com'
        ARTIFACTORY_CREDENTIALS = credentials('artifactory-credentials')
    }

    stages {
        stage('Reboot Server') {
            steps {
                script {
                    ansiblePlaybook(
                        playbook: "${ANSIBLE_PLAYBOOK}",
                        inventory: "${ANSIBLE_INVENTORY}",
                        extras: "--become --extra-vars '
ansible_become_pass=${env.ANSIBLE_SSH_PASS}'"
                    )
                }
            }
        }
        stage('Build') {
            steps {
                // Replace with your build steps, e.g., Maven, Gradle
                echo 'Building the application...'
            }
        }
        stage('Test') {
            steps {
                // Replace with your testing steps
                echo 'Running tests...'
            }
        }
        stage('SonarQube Scan') {
            environment {
                SONARQUBE_URL = "${SONARQUBE_SERVER}"
            }
            steps {
                withSonarQubeEnv('SonarQube') {
                    sh 'sonar-scanner -Dsonar.projectKey=my_project 
-Dsonar.sources=. -Dsonar.host.url=${SONARQUBE_URL} 
-Dsonar.login=${SONARQUBE_TOKEN}'
                }
            }
        }
        stage('Fortify Scan') {
            steps {
                script {
                    // Assuming Fortify command-line tools are 
installed and configured
                    sh "sourceanalyzer -b my_project -scan -f 
my_project.fpr -url ${FORTIFY_SERVER} -token ${FORTIFY_TOKEN}"
                }
            }
        }
        stage('Artifact Storage') {
            steps {
                script {
                    // Replace with your artifact storage steps
                    sh "curl -u ${ARTIFACTORY_CREDENTIALS} -T 
./path/to/your/artifact.ext https://${ARTIFACTORY_SERVER}/
artifactory/path/to/repo/"
                }
            }
        }
    }

    post {
        always {
            cleanWs()
        }
    }
}

Ansible Playbook (reboot-server.yml)

yaml
---
- name: Reboot Red Hat Server
  hosts: all
  become: yes
  tasks:
    - name: Reboot the server
      ansible.builtin.reboot:
        reboot_timeout: 300

Inventory File (hosts)

css
[all]
redhat-server-1 ansible_host=your.server.ip ansible_user=your_ssh_user 
ansible_ssh_private_key_file=/path/to/ssh_key

Adding Credentials in Jenkins

1. Ansible SSH Key:

   • Go to Jenkins Dashboard > Credentials > System > Global credentials (unrestricted).
   • Add a new credential of type "SSH Username with private key".
   • Add your SSH key file for the Red Hat Server.

2. SonarQube Token:

   • Go to Jenkins Dashboard > Credentials > System > Global credentials (unrestricted).
   • Add a new credential of type "Secret text".
   • Enter your SonarQube API token.

3. Fortify Token:

   • Repeat the same steps as for the SonarQube Token, but use your Fortify API token.

4. JFrog Artifactory Credentials:

   • Add a new credential of type "Username with password".
   • Enter your Artifactory username and API key.

Summary

This Jenkins pipeline script is designed to:

1. Reboot a Red Hat Server 9 using Ansible.
2. Build the application (customise the build steps according to your project).
3. Run tests (customise the test steps according to your project).
4. Perform a SonarQube scan for code quality analysis.
5. Perform a Fortify scan for security analysis.
6. Upload the artifact to JFrog Artifactory.

Make sure to replace placeholder steps with your actual build and test commands, and ensure that your Jenkins environment is configured correctly with the necessary tools and credentials.