*Kubernetes Terminology
*Kubernetes Architecture
*Kubernetes Cluster Architecture
*Kubernetes API Primitives
*Kubernetes Services and Network Primitives

*Cluster Communications
*Pod and Node Networking
*Container Network Interface (CNI)
*Service Networking
*Ingress Rules and Load Balancers
*Cluster DNS

*Managing Data in the Kubernetes Cluster
*Persistent Volumes
*Volume Access Modes
*Persistent Volume Claims
*Applications with Persistent Storage

*Building the Kubernetes Cluster on Ubuntu
*Release Binaries, Provisioning and Types of Clusters
*Installing Kubernetes Master and Nodes
*Building a Highly Available Kubernetes Cluster
*Configuring Secure Cluster Communications
*Testing The Cluster

*Pod Scheduling within the Kubernetes Cluster
*Configuring the Kubernetes Scheduler
*Running Multiple Schedulers for Multiple Pods
*Scheduling Pods with Resource Limits and Label Selectors
*DaemonSets and Manually Scheduled Pods
*Displaying Scheduler Events

*Managing the Kubernetes Cluster
*Upgrading the Kubernetes Cluster
*Backing Up and Restoring a Kubernetes Cluster

*Deploying Applications in the Kubernetes Cluster
*Deploying an Application, Rolling Updates, and Rollbacks
*Configuring an Application for High Availability and Scale
*Creating a Self-Healing Application

*Comparison with Docker Swarm
*Orchestration and Various Tools
*History of Kubernetes

*Securing the Kubernetes Cluster
*Kubernetes Security Primitives
*Cluster Authentication and Authorization
*Creating TLS Certificates

Enroll in our Certified Kubernetes Administrator (CKA) course to master Kubernetes administration. Gain hands-on experience and earn certification to advance your DevOps career.

Certified Kubernetes Administrator (CKA) Course | DevLabs

self

solo

live

*Installing GitLab
*Configuring GitLab
*User settings and permissions
*Getting started with GitLab


*Continuous Integration settings
*Git configuration options
*Monitoring GitLab
*Troubleshooting GitLab
*Use Cases
*Projects
*Account

*Using Docker images
*API
*Auto DevOps
*SSH authentication
*Kubernetes integration
*GitLab Pages
*GitLab Container Registry
*Complete DevOps with GitLab

*Updating GitLab
*GitLab platform integrations
*Project settings
*Repository settings


*GitLab Basics: Start working on your command line and on GitLab
* GitLab Workflow
* GitLab Markdown
* GitLab Flow
*Customizing GitLab appearance

*Gitlab Groups
*Gitlab Discussions
*GitLab Flavored Markdown
*Gitlab Todos
*Gitlab Search
*Gitlab Snippets
*Gitlab Integrations
*Gitlab Webhooks
*Gitlab API

*Cloning a Git Repository
* Recording Changes to the Repository
* Viewing the Commit History
*Git logs
*Undoing Things
*Working with Remotes
*Git Aliases

*About Version Control
*A Short History of Git
*Git Basics
*The Command Line
*Installation and setup of Git on Unix
*Installation of Git on Windows

Enroll in our GitLab Certified CI/CD Associate course to master continuous integration and deployment with GitLab. Achieve certification and advance your DevOps career with hands-on training.

GitLab Certified CI/CD Associate Course | DevLabs Alliance

*Kubernetes Terminology
*Kubernetes Components
*Kubernetes Cluster Architecture
*Understanding Kubernetes Master Components
*Kube-apiserver
*ETCD
*Kube-scheduler
*Kube-controller
*Kube-DNS
*Understanding Kubernetes Node Components
*Kube-proxy
*Kubelet
*Container Runtime
*Understanding the difference between the master and worker nodes

*Role and ClusterRole
*RoleBinding and ClusterRoleBinding
*Referring to resources
*Aggregated ClusterRoles
*Referring to subjects
*Default roles and role bindings
*Auto-reconciliation
*API discovery roles
*User-facing roles
*Privilege escalation prevention and bootstrapping
*Restrictions on role creation or update
*Restrictions on role binding creation or update

*SSH Keys
*Configure Ansible Vault
*Securing Passwords Using Vault
*Executing with Ansible Vault

*Basic Job Structure
*Parameters
*Build Environment
*Build Step
*Post Build Step
*Notifications
*Building a Free Style Job in Jenkins

*Searching, Filtering and Pulling Images
*Docker Image save/load
*Commit Container State
*Understanding Docker Image Directives
*Understanding the use of Base Images
*What is “FROM scratch”?
*RUN vs CMD
*COPY vs ADD
*Building Custom Images using Dockerfile
*Understanding Image Layers
*Publishing the Custom Image
*Flatten an Image using export/import
*Tagging Images
*Working with Docker Hub
*Pushing Docker Images to Docker Hub
*Working with Local Registry Service
*Lab: Working with Docker Images
*Lab: Building Custom Images
*Lab: Working with Docker Hub
*Lab: Setting up Local Registry Service

*Creating, Starting and Listing Containers
*Attaching and Detaching from Container
*Fetching Container details using “inspect”
*Executing Commands inside a Container
*Pause, Stop, Start, Restart and Kill a Container
*Container Metrics via stats
*Limiting Memory and CPU utilization
*Storage Utilization of a Container
*Expose Container Application using Host Port
*Lab: Managing Container Lifecycle

*Orchestration and Various Tools
*History of Kubernetes
*Features of Kubernetes
*What Kubernetes is not!
*Kubernetes Versions

*What is Docker?
*Why Docker?
*Containerization v/s Virtualization
*Docker Architecture
*Understanding the Docker components
*Docker Terminologies
*Docker Internals

*Understanding various Network Plug-ins
*Understanding the default Docker Networking
*Working with Bridge Network
*Working with Host and None Networks
*Lab: Managing Docker Networking

*Understanding need of Volume service in Docker
*Understanding various Volume Plug-ins
*Create and Manage Volumes
*Start a container with a Volume
*Populate data in a Volume using a Container
*Use a read-only Volume
*Migrating Volumes between Containers
*Lab: Creating and Manage volumes

*Understanding different tools for deploying Kubernetes Cluster
*Release Binaries, Provisioning and Types of Clusters
*Building the Kubernetes Cluster using kubeadm
*Installing Kubernetes Master and Nodes
*Configuring Secure Cluster Communications
*Testing the Cluster
*Lab: Deploying Kubernetes Cluster using Kubeadm
*Lab: Adding Nodes to Kubernetes Cluster

*Installing Helm
*Using Helm
*Chart Development Tips And Tricks
*Syncing Your Chart Repository
*Chart Releaser Action To Automate GitHub Page Charts
*Charts
*Chart Hooks
*Chart Tests
*Library Charts
*Helm Provenance And Integrity
*The Chart Repository Guide
*Registries
*Helm Architecture

*Managing Data in the Kubernetes Cluster
*EmptyDir, hostPath, PV, PVC, StorageClass
*Volume Access Modes
*Applications with Persistent Storage
*ConfigMaps
*Secrets
*Lab: Working with Kubernetes Volume Service
*Lab: Configuring Dynamic Volume Service
*Lab: Working with ConfigMaps and Secrets

*Building an Ansible Inventory
*Ansible Configuration Files
*Running Ad Hoc Commands
*Managing Dynamic Inventories
*Ansible Modules
*Ansible Plugins

*Troubleshooting Playbooks
*Troubleshooting Ansible Managed Hosts
*Ordering Problems
*Jumping to Specific Tasks
*Retrying Failed Hosts
*Syntax-Check and Dry-Run
*Debugging

*Managing Plugins
*Updating Plugins
*Adding Plugins

*Intro and Topics
*Understanding How GitOps Applies to Your Career
*Selling GitOps to Your Leadership
*Understanding How to Onboard GitOps On Your Next Project
*Understanding Resources For GitOps
*Summary

*Intro and Topics
*Enabling a GitOps IaC Workflow
*Enabling a GitOps Workflow Using Flux
*Demo: GitOps in Action with Azure Arc Enabled Kubernetes
*Summary

*Introduction to Docker Swarm
*Docker Swarm vs Kubernetes

*Introduction to Compose
*Understanding docker-compose file
*Docker Compose Use Cases
*Lab: Deploying Multi-tier App with Docker Compose

*Pod Scheduling within the Kubernetes Cluster
*Configuring the Kubernetes Scheduler
*Running Multiple Schedulers for Multiple Pods
*NodeName Taints, Tolerances, Node Selector, labels & Selectors
*Taint vs Tolerations vs Node Affinity/AntiAffinity
*Scheduling Pods with Resource Limits and Label Selectors
*Displaying Scheduler Events

*Why Terraform – picking the right tool
*Desired and current states
*Understanding Resources and Providers
*Terraform Code
*AWS Fundamentals & Services offered
*Automated deployment on AWS

*Introduction
*Docker and the Kernel
*A Linux Container Running on Windows 10
*What Is a Kernel?
*Running Linux Containers on Windows
*Jenkins on Docker
*Jenkins in a Container
*Maintaining State outside the Container
*The Docker File System
*Understanding Copy on Write
*Mounting a Volume to Your Container

*Automate common Linux system administration tasks with Ansible.

*Setting up a Build Agent
*Distributing a Build
*Monitoring Build Agents

*Permissions
*Configuration
*Updates and Maintenance
*Notifications and Alerts (Email) and Logging

*Application LivenessProbe
*What is LivenessProbe and why do you need it?
*Implementing LivenessProbe
*Application ReadinessProbe
*Why do you need ReadinessProbe?
*Implementing ReadinessProbe
*Using ReadinessProbe and LivenessProbe together
*Application Startupprobe
*Lab: Working with LivenessProbe and ReadinessProbe

*Ansible Roles Structure
*Creating Roles
*Deploying Roles with Ansible Galaxy

*Continuous Integration
*Continuous Delivery
*Continuous Deployment
*Source Control Management
*Branches
*Artifacts
*Code Testing
*Code Vulnerabilities Scan
*Distributed Builds

*Artifacts and Fingerprints
*Linking Jobs
*Automating Jobs
*Triggering Builds with Git Hooks

*Creating a ReplicaSet object
*Testing the behavior of ReplicaSet
*Scaling ReplicaSet
*Deleting a ReplicaSet object
*Creating a Deployment object
*Exposing Deployment Pods using Service objects
*Scaling a Deployment object
*Deleting a Deployment object
*How does a Deployment object manage revisions and version rollout?
*Updating a Deployment object
*Rolling back a Deployment object
*Deployment object best practices
*Use declarative object management for Deployments
*Do not use the Recreate strategy for production workloads
*Do not create Pods that match an existing Deployment label selector
*Carefully set up your container probes
*Use meaningful and semantic image tags
*Migrating from older versions of Kubernetes
*Lab: Deploying Application using Replication Controller
*Lab: Deploying Application using Replica Set
*Lab: Rolling Updates and Rollbacks using Deployment
*Lab: Deploying Application using Daemon Set
*Lab: Deploying StatefulSet Application
*Lab: Deploying Multi-Tier Application
*Lab: working with Job and CronJob

*Why do you need NetworkPolicy?
*Understanding Pods are not isolated by default
*Basics
*DENY all traffic to an application
*LIMIT traffic to an application
*ALLOW all traffic to an application
*Namespace’s level
*ALLOW traffic to an application from all namespaces
*ALLOW all traffic from a namespace
*ALLOW traffic from some pods in another namespace
*Advanced
*ALLOW traffic only to certain port numbers of an application
*ALLOW traffic from apps using multiple selectors
*Managing Clusters
*Managing the Kubernetes Cluster
*Upgrading the Kubernetes Cluster
*ETCD Backing Up and Restoring a Kubernetes Cluster
*Lab: Upgrading Kubernetes Cluster
*Lab: ETCD Backing Up and Restoring a Kubernetes Cluster

*Loops and Conditionals
*Handlers
*Limiting Execution by Hosts (limit)
*Limiting Execution by Tasks (tag)
*Adding and Meeting Conditionals
*Handling Errors

*Ubuntu
*CentOS/RedHat
*MacOS
*Windows
*Docker Container
*Deploying Jenkins in Public Cloud (AWS)

*Upload Artifacts to Jfrog artifactory
*Send Build Notifications using Slack
*Continuous Deployment to Tomcat Apache using Deploy plugin
*Integration with SonarQube to scan source code with vulnerabilities

*Cluster Communications
*Pod and Node Networking
*Container Network Interface (CNI)
*Service Networking
*ClusterIP, NodePort & Load Balancer
*Understanding Pod IP assignment
*Understanding Pod IP assignment is dynamic
*Never hardcode a pod's IP addresses in your application code
*Understanding how services route traffic to Pods
*Understanding how DNS names are generated for services
*Understanding the different types of services
*Why do you need ClusterIP services?
*ClusterIP services to expose my Pods?
*Listing ClusterIP services
*Creating ClusterIP services using the imperative way
*Describing ClusterIP services
*Creating ClusterIP services using the declarative way
*Deleting ClusterIP services
*Understanding headless services
*Why do you need NodePort services?
*Understanding NodePort
*YAML definition
*Making sure NodePort works as expected
*Listing NodePort services
*Adding more Pods to NodePort services
*Describing NodePort services
*Deleting NodePort services
*NodePort or kubectl port-forward?
*Ingress Rules
*Cluster DNS
*Lab: Exposing Applications using various types of Services
*Lab: Install and Configure Ingress Controller to expose nginx based Service

*Environment Setup
*Hardware and Software requirements
*How to install Ansible?
*How Ansible works?
*Ansible CLI

*Introduction to IaC
*Difference between GUI, CLI and IaC
*Why IaC
*Multiple Tools and services available for IaC
*Terraform Basics

*SCM in Builds
*Build Tools (Maven)
*Testing and Test Reports

*Pod Overview
*Creating a Pod with imperative syntax
*Creating a Pod with declarative syntax
*Reading the Pod's information and metadata
*Listing the objects in JSON or YAML
*Backing up your resource using the list operation
*Getting more information from the list operation
*Accessing a Pod from the outside world
*Entering a container inside a Pod
*Deleting a Pod
*Understanding Pod Lifecycle
*Multi-container Pod
*Concrete scenarios where you need multi-container Pods
*When not to create a multi-container Pod
*Creating a Pod made up of two containers
*What happens when Kubernetes fails to launch one container in a Pod?
*Deleting a multi-container Pod
*Understanding the Pod deletion grace period
*Accessing a specific container inside a multi-container Pod
*Running commands in containers
*Overriding the default commands run by your containers
*Static Pod
*Init Containers
*Sidecar container pattern
*Labeling and annotating the Pods
*What are labels and why do we need them
*What are annotations and how do they differ from labels
*Adding a label
*Listing labels attached to a Pod
*Adding or updating a label to/of a running Pod
*Deleting a label attached to a running Pod
*Adding an annotation
*Lab: Imperative Commands and Formatting Output with kubectl
*Lab: Working with Single Container Pods
*Lab: Creating multi container Pod
*Lab: Creating init container Pod
*Lab: Working with Static Pod
*Lab: Working with label and selector

*What is Ansible and Features
*History and Releases
*Agent versus Agentless
*Ansible Architecture
*Infrastructure as Code
*Idempotency
*Use cases

*Selecting Hosts with Host Pattern
*Configuring Delegation
*Configuring Parallelism

*Exploring the GUI
*System Configuration
*Security Configuration
*Jenkins
*Job Configuration

*Intro and Overview
*Understanding What Gitops Is
*Understanding the Need for GitOps
*Understanding the Benefits of GitOps
*Understanding the Difference between GitOps and DevOps
*Understanding the Difference between GitOps and IaC
*GitOps Principles and Practices
*Summary

*Intro and Topics
*Understanding GitOps Tooling
*Understanding a GitOps Architecture
*Understanding GitOps Architectural Decision Points
*Demo: Deploy New Application Using Argo CD GitOps Too
*Summary

*Describe Resources
*Pod/container logs
*Metric Server & top command
*Events
*Lab: Working on Logs and Events
*Lab: Working with Metric Server
*Lab: working with HPA

*Terraform commands & state files
*Destroying Infra with Terraform
*Understanding Attributes and Output Values in Terraform
*Understanding Provisioners in Terraform
*Understanding terraform HCL
*Terraform Variable
*Terraform Variable Types
*Outputting attributes
*Data Sources
*Terraform Modules
*Interpolation
*Conditionals
*For & For-Each loop

*Pipeline Jobs
*The Blue Ocean Editor
*Scripted Pipelines
*Declarative Pipelines
*Groovy and DSL
*Jenkins File Basics
*Pipeline Triggers
*Multi branch Pipelines
*Global Libraries
*Variables and Credentials
*Dockerizing an app
*Deploying a Docker Container with Jenkins Pipelines

*Docker Editions
*Hardware and Software Requirements
*Installing Docker
*Docker Config Files and Settings
*Lab: Installing Docker on Linux

Enroll in our Certified Advanced DevOps Course to master high-level DevOps practices. Gain hands-on experience and certification to elevate your DevOps career.

Certified Advanced DevOps Course | DevLabs Alliance

*Deploying an Application, Rolling Updates, and Rollbacks
*Configuring an Application for High Availability and Scale
*Configuring ConfigMaps in Applications
*Creating a Self-Healing Application

*Helm Charts
*Charts hooks
*Chart Test
*Helm Architecture

*Monitoring the Cluster Components
*Monitoring the Applications Running within a Cluster
*Managing Cluster Component Logs
*Managing Application Logs
*Horizontal Pod Auto-scaling (HPA)
*Grafana
*Prometheus
*Open Lense

*Introduction to Pods
*What is a Pod?
*Pod Lifecycle & Comparison with Docker
*Create Pods & Manage multiple containers
*Replication Controller
*Replication sets
*Deployments
*Scaling out pods using replicas
*What is a Service?
*Types of Services in k8s
*Multi Container PODs
*Namespaces
*Labels
*Kubernetes dashboard

*What is Kubernetes & why
*Kubernetes Terminology
*Kick start Kubernetes
*Comparison with Docker Swarm
*Installing Kubernetes manually and on premise
*Configuring AWS- CLI for launching EKS
*I am roles
*Configuring Azure service AKS

*Pod and Node Networking
*Container Network Interface (CNI)
*Service Networking
* Load Balancers
*Cluster DNS

* About Docker
*  Installation
*  Running Containers
*  Images
*  Volumes
*  Swarm
*  Service
*  Stack

*Upgrading the Kubernetes Cluster
*Operating System Upgrades within a Kubernetes Cluster
*Backing Up and Restoring a Kubernetes Cluster

*Installation
*Initialize the cluster
*Setup the POD network
*Build high availability cluster
*Validate the cluster

*Persistent Volumes
*Volume Access Modes
*Persistent Volume Claims
*Storage Objects
*Applications with Persistent Storage

*Kubernetes Master&Minnions
*Kube Api server
*etcd key-value store
*kube Scheduler
*kube Controller-manager
*Introduction to Minnions / Nodes
*kubelet
*kube-proxy
*kubectl Client

Enroll in our Docker with Kubernetes Certification Course to master containerization and orchestration. Gain hands-on experience and earn certification to advance your DevOps career.

Docker with Kubernetes Certification Course | DevLabs

*Maven Life Cycle
*Maven Installation
*Maven POM XML File

*What Is Splunk
*About Machine Data
*What does Splunk Do?
*Why Splunk
*Understanding Splunk Architecture & its Components
*Installation of Splunk and Forwarder
*Splunk Search
*Use cases and Examples

*Introduction to Configuration Management
*Popular Configuration Management Tools
*Ansible
*Puppet
*Ansible commands
*Ansible Playbooks

*Overview
*About Continuous Integration
*Introduction to Jenkins and the History of Jenkins
*Configuring Jenkins
*Create Our First Jenkins Job
*Run our First Jenkins Job
*Continuous Integration (CI) with Jenkins
*Continuous Delivery with Jenkins

*Version Control System
*Centralized & Distributed Version Control System
*GIT Features
*GIT Commands
*GIT Remote
*Advantages of GIT

*What and why is Kubernetes
*Comparison with Docker Swarm
*Pods
*Replications
*Services
*Deployment

*Introduction to Infrastructure Monitoring
*Various tools
*Nagios
*Prometheus
*Grafana
*Container monitoring with Prometheus and Grafana

What is DevOps?
IT Evolution
History of DevOps
Different Teams Involved
DevOps definitions
DevOps and Software Development Life Cycle
Waterfall Model
Agile Model
DevOps main objectives
Prerequisites for DevOps
Continuous Testing and Integration
Continuous Release and Deployment
Continuous Application Monitoring
Configuration Management
DevSecOps & DevChatOps
Containerization and Orchestration
What is Cloud?
History and evolution of cloud
Cloud Computing Concepts
Public, Private, Hybrid Clouds
IAAS, SAAS, PAAS Cloud Models
AWS Cloud setup
DevOps Toolset

*Introduction to Containers
*Docker Setup
*Docker Images
*Docker Commands

Enroll in our Certified DevOps Foundation course to master DevOps principles and practices. Gain hands-on experience and earn certification to advance your IT career.

Certified DevOps Foundation Course | DevLabs Alliance

*Infrastructure monitoring Intro
*Nagios Core vs XI
*Setting up Nagios
*Configuring Windows & Linux Hosts
*Configuring Alerts and Email Notifications
*Plugins
*Introduction to Prometheus and Grafana
*Container monitoring with Prometheus and Grafana

*Introduction to JPaC
*Types of JPaC
*Declarative
*Scripted
*Pipeline as a code basics
*Building a basic CI pipeline as code for Java app
*Building a job from pipeline code present in GIT repo.
*Executing parallel stages in a pipeline
*Generating pipeline script & directives using Jenkins inbuilt generators

*Linux Introduction
*Linux commands and tools, and file operations in Linux
*User Administration
*Boot and Package Management
*Linux process and scripting
*Security Administration, Shell Scripting and Virtualization
*Networking

*Image? What is it in Docker World?
*Official Docker Image Specification
*Centre for Images: The Docker Hub (Public)
*List of Official Docker Images
*Working with Images: image layers, tagging, Pushing to Docker Hub
*Building Images: The Dockerfile Basics
*Build Your Own Dockerfile and Run Containers

*Introduction
*Ansible Server / Ansible Controller
*Ansible and Infrastructure Management
*Ansible Server Configuration file
*How Ansible picks the configuration
*Update MISC parameters
*Ansible Inventory
*Ungrouped Hosts
*Grouped Hosts
*Groups of Groups
*checking connection to remote nodes o SSH Keys
*Using username/password
*Ansible Facts
*Ansible Playbooks
*‘hosts’ parameter
*‘become’ parameter
*‘gather_facts’ parameter
*‘tasks’ parameter
*Conditions
*Loops
*with_items
*How to store output of one task and use it in another task
*Variables
*Roles
*MISC
*Ansible Vault
*Ansible Pull
*Ansible Galaxy
*Ansible AWX (Tower)
*Use cases and Examples
*Overview of Puppet
*Comparison of Ansible and Puppet

*What is DevOps?
*IT Evolution
*History of DevOps
*Different Teams Involved
*DevOps definitions
*DevOps and Software Development Life Cycle
*Waterfall Model
*Agile Model
*DevOps main objectives
*Prerequisites for DevOps
*Continuous Testing and Integration
*Continuous Release and Deployment
*Continuous Configuration Management
*Continuous Application Monitoring
*DevOps Toolsets

*Archive Build Artifacts
*Install and Configure Tomcat as the Staging Environment
*The latest Deploy to Container plug-in
*Jenkins Build Pipeline
*Parallel Jenkins Build
*Master and slave
*Deployment

*Evolution of Microservices
*Monolithic Architecture
*Service Oriented Architecture
*What is Microservice
*SOA vs Microservice
*Microservice Develop
*Write First Microservice
*Microservice Testing
*Testing Scenarios and Strategy
*Test at Different levels
*Deploying Microservice
*Setting Up CICD pipeline
*Touchless Deployment to Prod Environment

*Java Compiler
*Maven Life Cycle
*Maven Installation
*Maven build requirements
*Maven POM XML File

*Container VS. VM
*Detached and Interactive Modes
*What Happens When We Run a Container?
*What`s Going on In Containers: CLI Process Monitoring
*Getting a Shell Inside Containers
*Container Lifetime & Persistent Data Using Volumes
*Docker container Networking, default & user defined networks

*Version Control System
*Introduction to Version Control and Git
*Git Basics: Cloning, Committing, and Checking Out
*Git Basics: Reviewing History and Undoing Changes
*Branching in Git
*Merging and Resolving Conflicts in Git
*Git Branching Strategies
*Introduction to Remote Repositories
*Collaborating on GitHub/GitLab: Forking and Pull Requests
*Collaborating on GitHub/GitLab: Branch Permissions
*Git Tags and Releases
*Advanced Git Commands: Rebasing and Cherry-picking
*Git Aliases and Configuration
*Git Stash and Workflows

*Docker Hub (public repo)
*Docker Trusted Registry (Private repo)
*Docker Engine
*Docker Container
*Docker Image

*Automating Tetris Deployments with Argo CD, Terraform, and Jenkins

*Introduction to Cloud Computing
*Introduction to cloud computing world
*History
*Cloud business models
*Public, Private and Hybrid cloud models
*Advantages of cloud computing
*AWS Regions and Availability zones. Tools to access services.
*AWS Cloud Setup – Free Tier
*Overview of the console
*Aws Ec2 (Elastic Compute Cloud)
*Aws S3 (Simple Storage Service)
*Security Groups
*AWS Auto Scaling
*AWS Load Balancer
*Virtual Private Control
*IAM
*AWS EKS (Elastic Kubernetes Service)
*ECR (Elastic Container Registry)

*Overview & Setup
*What is docker & why
*Docker Editions: Which Do I Use
*Docker Version Format Change in Early 2017
*Docker Support for Different OS
*Docker for Windows
*Docker for Mac
*Docker for Linux
*Docker for Linux Setup and Tips
*Download Docker CE for your Linux distribution

*Getting started with Jenkins
*Overview
*How to Take this Course and How to Get Support
*About Continuous Integration
*Introduction to Jenkins and the History of Jenkins
*Install Java
*Install Jenkins
*Jenkins’ Architecture and Terms of Jenkins
*Overview of Jenkins UI:
*Dashboard and Menus
*Create Our First Jenkins Job
*Run our First Jenkins Job
*Email configuration, Global Security, Master-Slave Architecture

*Install Git and Jenkins GitHub Plugin
*Install Maven on Our Local Box
*Configure Jenkins to Work with Java, Git and Maven
*Text Direction: Create our First Maven-based Jenkins Project
*Create our First Maven-based Jenkins Project
*CI Pipeline
*Compile
*CodeReview
*UnitTest
*CodeCoverage
*Package
*Integration with JFrog and Sonar
*Run our First Jenkins Build and Jenkins Workspace
*Trouble Shooting: Run our First Jenkins Build and Jenkins Workspace
*Triggers in Jenkins

*What and why is Kubernetes
*Comparison with Docker Swarm
*Installation
*Components and Terminology
*Masters and Nodes
*Pods
*Replications
*Services
*Deployment

*Introduction to Configuration Management
*Introduction to Provisioning
*Infrastructure as a code
*About Terraform
*Setting up Terraform
*Understanding HCL
*Basics of Terraform — variables, templates, modules & commands
*Terraform for Local Changes
*Terraform on AWS
*Terraform on Google Cloud

Enroll in our DevOps Professional Certification Course to master DevOps practices. Gain hands-on experience and earn certification to advance your career.

DevOps Professional Certification Course | DevLabs Alliance

*9.1 Building a security culture 
*9.2 Communication and collaboration 
*9.3 Automation and self-service

*12.1 Emerging technologies and practices 
*12.2 DevSecOps in a changing landscape 
*12.3 Continuous improvement and adaptation

*4.1 Shift-left security 
*4.2 Security as code 
*4.3 Threat modeling 
*4.4 Security testing in CI/CD pipelines

*10.1 DevSecOps toolchain overview 
*10.2 Popular DevSecOps tools (e.g., GitLab, Jenkins, SonarQube) 
*10.3 Integrating security tools

*3.1 Basic principles of cybersecurity 
*3.2 Common security threats and vulnerabilities 
*3.3 Regulatory compliance and industry standards

*5.1 Secure coding practices 
*5.2 Secure design principles 
*5.3 Code review and analysis 
*5.4 Secure development frameworks

*7.1 Cloud security fundamentals 
*7.2 Infrastructure as Code (IaC) security 
*7.3 Identity and access management (IAM) 
*7.4 Cloud-native security tools

*13.1 Practical exercises to reinforce learning 
*13.2 Building secure CI/CD pipelines 
*13.3 Security testing and vulnerability remediation

*2.1 Understanding DevOps principles 
*2.2 Continuous Integration (CI) and Continuous Deployment (CD) 
*2.3 Automation and collaboration

*6.1 Introduction to containerization 
*6.2 Container security best practices 
*6.3 Scanning container images for vulnerabilities 
*6.4 Runtime container security

*11.1 Real-world DevSecOps success stories 
*11.2 Lessons learned and best practices 
*11.3 Challenges and how to overcome them

*1.1 What is DevSecOps? 
*1.2 The need for DevSecOps 
*1.3 Benefits and challenges

*8.1 Regulatory compliance (e.g., GDPR, HIPAA, PCI DSS) 
*8.2 Auditing and monitoring 
*8.3 Security incident response

Enroll in our Certified DevSecOps Professional course to master integrating security into DevOps lifecycles. Gain hands-on experience and earn certification to advance your career.

Certified DevSecOps Professional Training | DevLabs Alliance

Learn the skills to bridge the gap between software development and deployment. Our DevOps course helps you master the skills of a DevOps engineer in no time. From knowing about various cloud services to delivering high-quality products, learn how everything works in the professional world. Be a master at DevOps and see your career take a leap ahead of others.

DevOps

*Introduction to NUnit
*Integrating NUnit with Selenium
*NUnit Annotations
*Writing Test Cases in Selenium using NUnit
*Generating reports with Selenium and NUnit


*Introduction to Database
*Connecting C# to database
*C# insert into database
*Update Records of database
*Deleting Records to database
*Step by Step Connection with Example
*C# File Operations

*Introduction to Automation Testing
*Tools for Automation Testing
*Why automation testing?


*Introduction to Testing Philosophy
*Introduction to C#


*Expected Conditions with Waits
*Page Load Timeout & Set Script Timeout property
*Wait Until Conditions
*Handle Simple, Confirmation & Prompt Alert
*Difference between Window Handle & Handles
*Action Class

*What is Automation Framework
*Types of Automation Framework
*Different Automation Framework with Examples
*Screenshots and Reporting

*What is Web-Driver?
*How to Launch Browsers?
*Architecture of Web-Driver
*Methods in Web-Driver
*Create your first script using Web-Driver
*Browser and Navigation Commands
*Web element commands, locators, checkboxes and radio buttons

Download specific EXE file for multiple Browser
Launching IE
Challenges with IE Browser
*IE driver server and path settings
*Launching Chrome
*Chrome server and path settings
*Parallel Test Execution
*Userlike Actions, Executing Javascript and Working with elements
*Running Tests on Different Drivers and Working With drivers in Selenium
*Selenium PhantomJS (Headless Browser) with a Scraper project
*Running Tests on Mobile Devices with Selenium and Appium


Learn Selenium automation with C#. Enroll in our certified professional training to master test automation frameworks and enhance your testing skills. Join now!

Certified Selenium with C# Training | Automation Course

*Python File Operation
*Python Directory
*Python Exception
*Exception Handling
*User-defined Exception
*Python Object and Class

*Arithmetic Operator
*Assignment Operator
*Comparison Operator
*Logical Operator
*Bitwise Operator
*Identity Operator
*Membership Operator

*Introduction to Page Object Model
*Introduction to Object Repository
*Need for Page Object Model
*Page Factory
*Implementing Page Object Model

*Python if…else
*Python for Loop
*Python while Loop
*Python break and continue
*Python Pass

*What is Automation Framework
*Types of Automation Framework
*Different Automation Framework with Examples

*Introduction to Python
*Installing Python
*Keywords and Identifier
*Statements & Comments
*Python Variables
*Python Data Types
*Python Type Conversion
*Python I/O and Import

*Introduction to PyTest Framework
*Installing PyTest
*PyTest Fixtures
*Running multiple tests using PyTest
*PyUnit Framework

Complete hands-on for one of the project assignments

*Introduction to Selenium WebDriver
*How to launch Browsers?
*Architecture of Webdriver
*Methods in WebDriver
*Create your first script using Webdriver
*Browser and Navigation Commands
*Web element commands, locators, checkboxes and radio buttons

Master Selenium with Python for test automation. Learn web automation testing techniques with hands-on online training from experts.

Selenium with Python Course | Learn Automation Testing

*Writing parameterized tests
*Using @Parameterized and @ValueSource annotations
*Custom parameter resolvers

*Overview of JUnit 5
*Migrating from JUnit 4 to JUnit 5
*New annotations and capabilities

*Mock exams and practice questions
*Review of course material and key concepts

*Analyzing JUnit usage in real-world scenarios
*Best practices from industry case studies

*Principles of TDD
*Writing tests before implementation
*Red-Green-Refactor cycle

*Writing effective and maintainable unit tests
*Test naming conventions
*Test granularity and isolation

*Verifying exception handling in code
*Using @Test (expected) and @Rule for handling exceptions
*Custom exception matchers

*Integrating JUnit tests into CI/CD pipelines
*Configuring build tools (e.g., Maven, Gradle)

*Introduction to mocking frameworks (e.g., Mockito)
*Creating mock objects
*Stubbing behavior

*Writing integration tests
*Setting up test environments
*Managing dependencies

*Writing performance tests
*Analyzing performance metrics
*Optimizing code for performance

*Understanding annotations like @Test, @Before, @After, etc.
*Organizing test suites
*Handling dependencies between tests

*Overview of JUnit framework
*Differences between JUnit 4 and JUnit 5
*Writing testable code

*Third-party extensions and plugins
*Customizing JUnit behavior

Become a JUnit expert with our certified training course. Learn advanced testing techniques and best practices for Java unit testing using JUnit framework.

Certified JUnit Expert Training | DevLabs Alliance

*Synchronizing Tests
*Adding Synchronization steps
*Standard and Text Checkpoints
*Different ways of inserting Checkpoints
*Enhance Tests with Checkpoints

*Introduction to Step Generator
*Generating script using Step Generator
*Advantages of Step Generator
*Disadvantages of Step Generator

*When is debugging used?
*Step Into
*Step Out
*Step Over

*Introduction to Framework
*Framework Folder Structure
*Different Types of Framework
*Advantages of Framework

*Introduction to Regular Expressions
*How to use Regular Expression in Descriptive Programming
*How to use Regular Expressions for Object Property Values
*How to use Regular Expressions in Standard Checkpoints
*How to use Regular Expressions in Text Checkpoints

*Standard Window Objects
*Web Objects
*Calling compiled Modules in QTP

*QTP Classes and Objects
*Object Identification
*Introduction to Object Repository
*Object Spy
*Object Properties
*Understanding the Expert view and the tree view
*Introduction to Checkpoints

*What is Checkpoint?
*Why Checkpoint is needed
*Types of Checkpoints
*Adding Checkpoints to a Test

*Defining the Quick Test Object Model: Objects, Methods, and Properties
*Translating Test Steps in Tree view to Expert view
*Enhance test cases in Expert view using Quick test functions and VBScript programming.

*Introduction to Keyword Driven Framework
*Development of Keyword function
*Calling keyword function to automate test case

*Basic Components in QTP
*QTP IDE
*QTP Benefits in Test Automation
*Test Planning
*Prepare for Test Case Automation

*Handling exception using Recovery Manager Wizard
*Usage of Recovery Manager Wizard
*Completing a Recovery Scenario
*Creating and associating .QRS file for Recovery Scenario

*Understanding, Creating, and Executing Basic Scripts
*Recording a sample test
*Understanding Recording levels
*Enhancement of recorded script
*Understanding QuickTest Results

*Parameterization of Tests
*Creating data-driven tests
*Local and Global Data Tables
*Working with Data Table
*Connecting the Data table to a database
*Importing an Excel file or Excel Sheet to the Data table

*Data Types, Variables, and Constants
*Arithmetic, Comparison, Concatenation, and Logical Operators
*Conditional Constructs
*Looping Constructs
*Arrays and Functions
*Important Inbuilt Functions

*What is Automation Testing?
*Advantages of Automation Testing
*Disadvantages of Automation Testing
*Difference between various Automation Testing tools

*What is Action?
*Types of Actions
*Methods to Import an Action
*Benefits of Test Modularity
*Creating Multiple Action Tests
*Configuring and Calling Reusable Actions

*Introduction to Virtual Object
*When Virtual Object is used
*Virtual Object Manager
*Limitations of Virtual Object

*How to start in Real-time projects
*Connecting to the Database
*Getting input value from the external Excel sheet

Become a Quality Test Professional with hands-on training and expert guidance. Prepare for a successful career in quality assurance and testing.

Quality Test Professional Certification | DevLabs Alliance

* Writing Cucumber Feature Files
* Implementing Step Definitions
* Running Cucumber Tests

* Handling Different Web Elements
* Synchronization in Selenium
* Working with Multiple Windows and Frames

* Introduction to Test Frameworks
* Setting Up TestNG
* Using Maven for Project Management

* Data-Driven Testing
* Page Object Model (POM)
* Handling Dynamic Web Elements

* What is BDD?
* Introduction to Cucumber
* Setting Up Cucumber

* Introduction to Selenium
* Setting Up Selenium
* Basic Selenium WebDriver Commands

Master automation testing with Selenium, Cucumber, and more. Learn advanced techniques for creating efficient test frameworks and scripts. Start your journey now!

Master Automation Testing with Selenium & Cucumber Framework

Want to become a software testing professional? Join the software testing course at DevLabs and dive deep into the concepts of manual and automated testing. Prepare a rewarding career for yourself and unleash the power of testing like never before. Our course covers everything from the basics of software testing to advanced-level defect management to prepare you to meet the needs of tomorrow.