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

Post a Comment

Popular posts from this blog

Maven Create and Build Artifacts

In Maven, you can create and build artifacts using the package phase of the build lifecycle. The package phase is responsible for taking the compiled code and other project resources and packaging them into a distributable format, such as a JAR (Java Archive), WAR (Web Application Archive), or other custom formats. Here are the steps to create and build artifacts using Maven: Configure the Build Output: In your project's pom.xml file, you need to configure the output of the build. This includes specifying the type of artifact you want to create (e.g., JAR, WAR) and any additional resources to include. You do this in the <build> section of your pom.xml: <build>     <finalName>my-artifact</finalName> <!-- Name of the artifact without the extension -->     <plugins>         <!-- Plugin configurations for creating the artifact -->         <!-- For example, maven-jar-plugin or maven-war-plugin -->     </plugins> </build> Depend
Post a Comment
Read more

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
1 comment
Read more

Maven Repositories (local, central, global)

Maven relies on repositories to manage dependencies, plugins, and other artifacts required for a project. There are typically three types of repositories in Maven: local, central, and remote/global repositories. Local Repository: Location: The local repository is located on your local development machine. By default, it's in the .m2 directory within your user home directory (e.g., C:\Users\<username>\.m2\repository on Windows or /Users/<username>/.m2/repository on macOS and Linux). Purpose: The local repository is used to store artifacts (JARs, POMs, and other files) that your machine has downloaded or built during previous Maven builds. These artifacts are specific to your local development environment. Benefits: Using a local repository improves build performance since it caches dependencies locally, reducing the need to download them repeatedly. It also ensures reproducibility by maintaining a local copy of dependencies. Central Repository: Location: The central repo
Post a Comment
Read more