Skip to main content

Syllabus_Old

Syllabus: DevOps

Course Objectives:

  1. To Introduce DevOps culture, tools and processes to use practically for organization and encourage effective collaboration to help individual contributors from different back grounds to work together productively.
  2. To Study DevOps Tools to Manage source code, build code, Deployment of the code and Monitoring deployed code.
  3. To Study the architecture that have the largest effects on Continuous Delivery and DevOps.
  4. To get acquainted with DevOps Tools and Technologies that helps to automate the software development process.

Course Outcomes : 

At the end of the course, students will be able to

  1. Describes key concepts, principles of DevOps and how DevOps fits in the wider world of Agile systems development.
  2. List and Illustrate the business benefits of DevOps, managing sourcecode, buildcode, Deploying the code, Monitoring deployed code and continuous delivery.
  3. Describes aspects of software architecture while working with DevOps.
  4. Use of DevOps tools for developing quality software and deploying that software’s easily, frequently, and reliably.

SECTION - I

Chapter 1 : Introduction to Devops(03)  

The History of Devops, Foundational Devops Terminology and Concepts, Devops: Adding it All Up, Common Devops Misconceptions, The Current State of Devops.


Chapter 2 : Collaboration: Individuals Working Together and Hiring :Choosing Individuals(06)  

Introduction, Individual Differences and Backgrounds, Individual Growth, Negotiation Styles, Communication, Trust and Empathy. Determining your Hiring Needs, Sourcing, Interviewing, Onboarding, Retention, Case Studies.

Chapter 3: Tools : Selection and Implementation(05)  

Introduction and Audience, Why Tools Matter, Why Tools Don’t Matter, Tool Ecosystem Overview, Auditing your Tool Ecosystem, Optimization: Selection and Elimination of Tools


Chapter 4: How DevOps Affects Architecture(08)  

Introducing software architecture, the monolithic scenario, Architecture rules of thumb, the separation of concerns, The principle of cohesion, Coupling, Back to the monolithic scenario, A practical example, Three-tier systems, The presentation tier, The logic tier, The data tier, Handling database migrations, Hello world in Liquibase, The change logfile, The pom.xmlfile, Manual installation, Micro services.

SECTION - II

Chapter 5 : Everything is Code(06)

The need for source code control, the history of source code management, Roles and code, which source code management system? source code management system migrations, choosing a branching strategy, branching problem areas, Artifact version naming, choosing a client, setting up a basic Git server, shared authentication, Hosted Git servers, Large binary files, Trying out different Git server implementations, Docker intermission, Gerrit, The pull request model, GitLab.


Chapter 6 : Building the Code(06)  

Introduction to build code, many faces of build systems, The Jenkins build server, Managing build dependencies, The final artifact, Cheating with FPM, Continuous Integration, Continuous Delivery, Jenkins plugins, The host server, Build slaves, Software on the host, Triggers, Job chaining and build pipelines, A look at the Jenkins file system layout, Build servers and infrastructure as code, Build phases, Alternative build servers, Alternative build servers, Collating quality measures, About build status visualization,Taking build errors seriously, Robustness


Chapter 7 : Deploying the Code(06)

Introduction to deployment systems, Configuring the base OS, delivering packages to a system, Virtualization stacks, executing code on the client, The Puppet master and Puppet agents, Ansible, PalletOps, deploying with Chef, deploying with SaltStack, Deploying with Docker.


Chapter 8 : Monitoring the Code(05)

Nagios, Munin, Ganglia, Graphite, Log handling


Text Books :

  1. Effective DevOps: Building a Culture of Collaboration, Affinity, and Tooling at Scale, Jennifer Davis & Katherine Daniels, OREILLY.
  2. Practical Devops: Harness the power of DevOps to boost your skill set and make your IT organization perform better. Joakim Veronam PACKT publishing Open source community experienced is tilled, Mumbai.


Reference Books:

  1. The DevOps2.1 ToolKit : Docker Swarm, Building, Testing, Deploying, and Monitoring services inside Docker Swarm clusters by Viktor Farcic Packt Birmingham, Mumbai.
  2. THE DEVOPS HANDBOOK : How to Create World-Class Agility, Reliability, &Security in Technology Organizations, By Gene Kim, Jez Humble, Patrick Debois, and John Wills


Internal Continuous Assessment (ICA):

ICA shall include the following :

Practical Assignments (minimum 10 to be implemented):

  1. Setup the HTTP Git Server for Private Projects.
  2. Implement GitHub operations.
    1. Create a Repository
    2. Create a Branch
    3. Make  a commit
    4. Openand merge Pull request
  3. Install Gerrit and SetUp SSH Keysin Gerrit, Customize the configuration variables to add your personal information (name and email).
  4. Implement How to Submit a Patch Using Gerrit commands.
  5. Create a new project and Fork a Project using GitLab.
  6. Implement following operation using GitLab
    1. Create a Branch
    2. Add a File
    3. GitLab-Rebase Operation
    4. Squashing Commits
  7. Automate Deployment using Jenkins plugin "Deploy to container Plugin".
  8. Use Jenkins “Deploy to container Plugin” and "build pipeline plugin" to implement continuous deployment and delivery of a project.
  9. Create Puppet Master Server.
  10. Automate application using Ansible Deployment Tool.
  11. Build a Web server Docker image which can be used to build containers.
  12. Create Monitoring Service in Nagios.
  13. Install Ganglia Monitoring Server and Create Monitoring Service from the Ganglia dashboard.



Comments

Popular posts from this blog

Experiment No. 5 Title: Applying CI/CD Principles to Web Development Using Jenkins, Git, and Local HTTP Server

  Experiment No. 5 Title: Applying CI/CD Principles to Web Development Using Jenkins, Git, and Local HTTP Server  Objective: The objective of this experiment is to set up a CI/CD pipeline for a web development project using Jenkins, Git, and webhooks, without the need for a Jenkinsfile. You will learn how to automatically build and deploy a web application to a local HTTP server whenever changes are pushed to the Git repository, using Jenkins' "Execute Shell" build step. Introduction: Continuous Integration and Continuous Deployment (CI/CD) is a critical practice in modern software development, allowing teams to automate the building, testing, and deployment of applications. This process ensures that software updates are consistently and reliably delivered to end-users, leading to improved development efficiency and product quality. In this context, this introduction sets the stage for an exploration of how to apply CI/CD principles specifically to web development using J

Experiment No. 6 Title: Exploring Containerization and Application Deployment with Docker

  Experiment No. 6 Title: Exploring Containerization and Application Deployment with Docker  Objective: The objective of this experiment is to provide hands-on experience with Docker containerization and application deployment by deploying an Apache web server in a Docker container. By the end of this experiment, you will understand the basics of Docker, how to create Docker containers, and how to deploy a simple web server application. Introduction Containerization is a technology that has revolutionised the way applications are developed, deployed, and managed in the modern IT landscape. It provides a standardised and efficient way to package, distribute, and run software applications and their dependencies in isolated environments called containers. Containerization technology has gained immense popularity, with Docker being one of the most well-known containerization platforms. This introduction explores the fundamental concepts of containerization, its benefits, and how it differs

Experiment No. 10 Title: Create the GitHub Account to demonstrate CI/CD pipeline using Cloud Platform.

  Experiment No. 10 Title: Create the GitHub Account to demonstrate CI/CD pipeline using Cloud Platform. Objective: The objective of this experiment is to help you create a GitHub account and set up a basic CI/CD pipeline on GCP. You will learn how to connect your GitHub repository to GCP, configure CI/CD using Cloud Build, and automatically deploy web pages to an Apache web server when code is pushed to your repository. Introduction: Continuous Integration and Continuous Deployment (CI/CD) pipelines are essential for automating the deployment of web applications. In this experiment, we will guide you through creating a GitHub account and setting up a basic CI/CD pipeline using Google Cloud Platform (GCP) to copy web pages for an Apache HTTP web application. Continuous Integration and Continuous Deployment (CI/CD) is a crucial practice in modern software development. It involves automating the processes of code integration, testing, and deployment to ensure that software changes are co