REST API

What are the roles and responsibilities of SDET?

SDET is a mix of developer as well as tester who has exposure to project management, and interacts and understands end-user software requirements.

What are the roles and responsibilities of SDET? - DevLabs Alliance

*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)

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

*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

*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

*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

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

*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

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

*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

*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

*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

*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

*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

*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

*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

*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

*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

In training for the Certified DevOps Professional Course, you learn principles of Continuous Integration, Deployment, Monitoring, and Delivery using tools like Puppet, Nagios, Chef, Ansible, Docker, Git, Jenkins, and many more.

Certified DevOps Professional Training Course - DevLabs Alliance

self

live

solo

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

*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

*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

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

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

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

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

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

This Docker with Kubernetes Certification Course by DevLabsAlliance is going to focus on a training program, to build applications in containers using Docker and how to deploy those on a Kubernetes cluster.

Docker with Kubernetes Certification Training Course

*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

*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

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


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

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

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

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


Become a GitLab Certified CI/CD Associate. Master CI/CD pipelines and DevOps 

GitLab Certified CI/CD Associate Course | Master CI/CD Skill

*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

*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

*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

*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

*Managing Plugins
*Updating Plugins
*Adding Plugins

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

*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

*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

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

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

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

*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

*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

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

*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

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

*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

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

*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

*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

*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

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

*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

*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

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

*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

*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

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

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

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

*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

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

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

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

*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

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

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

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

*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

*Automate common Linux system administration tasks with Ansible.

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

*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

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

*Ubuntu
*CentOS/RedHat
*MacOS
*Windows
*Docker Container
*Deploying Jenkins in Public Cloud (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

The training on the DevOps Advance Certification course covers advanced concepts and methodologies related to DevOps.

DevOps Advance Certification Training Course

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

*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

*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

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

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

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

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

*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

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

The Certified Kubernetes Administrator(CKA) Certification Training Program provides an excellent foundation course for the Certified Kubernetes Administrator exam by the Cloud Native Computing Foundation (CNCF)

Certified Kubernetes Administrator (CKA) Training - DevLabs Alliance

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

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

*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

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

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

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

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

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

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

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

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

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

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

The DevSecOps Certification Professional Training and Course provides an in-depth exploration of advanced principles and practices to seamlessly integrate security into the DevOps lifecycle.

Certified DevSecOps Professional Training Course

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

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

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

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

*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

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

*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

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

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

The Certified DevOps Foundation Certification Training Course gives a basic level of understanding of DevOps philosophy.

Certified DevOps Foundation Course and 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

*Appium Introduction
*What is Appium
*Appium Architecture
*Types of mobile applications

*Appium Setup on Windows
*Installing Appium CLI
*Installing Appium Driver
*Installing Appium Inspector
*Installing Android studio

*First Appium Project
*What is desired capability?
*Setup Maven Project
*First java program to start Appium driver
*Create driver session using Options class
*How to get AppPackage and AppActivity
*Launch Appium driver with appPackage and appActivity

*Native Application Automation
*Appium Inspector walkthrough
*Locator strategies

*Automating gestures
*Click
*Long click
*Drag and drop
*Swipe
*Scroll

*Appium driver commands
*Working with app
*Lock and unlock 
*Toggle Wifi, Toggle data and Airplane mode
*Working with keys
*Generation reports
*Capturing Screenshot

*Manage Ajax components
*Manage Complex Calendars
*How to Scroll Web page
*Handle WebTable with Paginations
*Manage infinite Page Loading like infinite page scrolling on Twitter, Facebook, shopping web apps
*Complex ShadowDOM, SVG Elements
*Complex Frames/iFrames
*Complex Psuedo Elements
*Page Wait for use cases
*Element Wait use cases
*How to Capture Screenshots
*How to work with Cookies
*Headless Browser Testing
*SSL Certificates Error Handling
*Execute Javascript Based code for Selenium Webdriver

*What is BDD(behavior Driven Development)?
*What tools are required to implement BDD?
*Introduction to Cucumber
*How to download Cucumber?
*Install Cucumber Eclipse Plugin
*Configure Eclipse with Cucumber
*What are Feature Files?
*How to create Feature File?
*How to execute Feature Files?
*What is Gherkinization?
*What is Step Definition?
*How to generate Glu code/Step Definitions?
*Data Driven Testing in Cucumber
*What are Cucumber Tags?
*Background in Cucumber
*Data Tables in Cucumber

*Difference between FindElement & FindElements
*Enter & Clear text from the Input field
*Click Action and How to Click action work differently on different elements
*Managing Input fields, Buttons & Links
*Finding all links on the Page
*Select More than one object from a page 
*Selecting Objects from a specific area of a web page 
*Check if the element is Present, Displayed, Enabled, or Selected

*Introduction and Component of Frameworks
*Phases in Designing Framework
*Step by Step Implementation of Hybrid Driven Framework
*Creating Maven Project
*Update pom.xml with dependencies
*Creating page objects and Object repository
*Creating utilities
*Setting up configuration files
*Creating automation test cases
*Creating data-driven test cases
*Creating database test cases
*Generating extent reports
*Generating logs using log4j2
*Execute test scripts using TestNG XML File
*Running tests with different Test Data
*Generating the HTML reports : Extent Report,TestNG Report
*Emailing test reports

*Introduction to Java Frameworks
*Most Popular Java Frameworks
*What is Spring Framework?
*Why use Spring?
*Advantages of Spring Framework
*How does Spring works?
*Dependency Injection
*Aspect Oriented Programming – AOP
*Spring Architecture
*Spring Modules

*Classes and Objects
*Arithmetic Operators & Concatenation operators
*Conditional & Decision Making
*Single Dimensional Array
*Loops (For, While)
*Java Constructors
*Java methods
*Passing parameters to the methods
*Call by value and call by reference
*Function Return Types
*Exception Handling
*Inheritance
*Polymorphism
*Encapsulation
*Data Hiding
*Method Overloading & Constructor Overloading
*Method Overriding
*Abstract class
*Interface
*Java Packages
*Access Modifiers
*Data conversion functions
*Reading Input from the keyboard
*Super/This Keywords
*Final/Finally/Finalize Keywords
*Concept of Garbage Collector and System.gc
*Wrapper Classes
*String Manipulation
*Collections Basics (Array List, HashMap, Set, Hashtable)

*Implicit and Explicit Waits
*Expected Conditions with Waits
*Page Load Timeout & Set Script Timeout property
*Implement wait by Thread Sleep
*Concept of Fluent Wait in Selenium 
*Strategy to poll for an object
*WebDriverWait and its uses 
*Various WaitUntil Conditions 
*Handle Ajax-based components 
*Various Ways to handle Simple, Confirmation & Prompt Alert
*Difference between Window Handle & Handles
*Switching & Closing Windows, Tabs & PopUps
*Concept of window ID 
*Extracting window IDs with a Selenium Object reference

*The architecture of Selenium WebDriver
*Understand WebDriver Interface
*WebElement Interface
*Launching Browsers e.g. Firefox/Chrome/Safari/Edge

*What is Maven and what Features of Maven?
*Installing/Configuring Maven
*Creating Maven Project
*Understanding POM.xml
*How To Add Dependencies to pom.xml
*How To Add plugins to pom.xml

*Introduction to MySQL
*Installation
*Create Database
*Drop Database
*Select Database
*Create Table
*Insert Query
*Select Query
*Delete Query
*Joins and more queries

*Find table rows and columns
*Extracting values from a cell
*Dynamically Identify Tables Data
*Select class in Selenium
*Drop Down Handle
*Select multiple values from the list
*Select & Unselect operations by Index, Value & Visible Text

*Introduction to API Testing
*Why is API testing important?
*What are Web Services?
*Understanding the REST API architecture
*Understanding the GET, POST, PUT, and DELETE requests

*Element Inspector in Mozilla, Chrome, and Edge
*Element locator tool for Firefox (Firebug)
*Various HTML locator strategies
*Developer Tools in Chrome to find Xpath
*Selection of Effective XPath
*Managing Dynamic objects/ids on the page

*Overview of DevOps
*Relationship between Agile and DevOps
*CI/CD Pipeline
*DevOps Toolchain
*Overview of DevOps tools

*Overview of GIT
*GIT Installation
*Create GIT Account
*GIT Lifecycle
*GIT Integration with Eclipse
*My First Code Check-in to GIT
*GIT PULL Request Process (PR, Merge Request)
*GIT CheckOut
*GIT Branching (Local branching Concept)
*GIT Clone
*GIT Commit
*GIT Push, Fetch & Pull Commands
*GIT Update
*GIT Delete
*GIT Stash


*What are Locators?
*Introduction to HTML basics
*HTML language tags and attributes 
*Identify ID, Name, Xpath, CSS from HTML Code
*Difference between Absolute & Complete Xpath
*Finding your first element
*WebElement Commands

*Introduction to TestNG
*Benefits and Features of TestNG
*Configure TestNG in Project
*How to write TestNG Test case
*Understanding testng.xml
*TestNG Report
*How to Prioritizing tests
*Annotations in TestNG – @Test, @BeforeTest, @AfterTest, @BeforeSuite, @Parameters
*dependsOnMethods
*How to Skip tests
*How to Group tests
*Assertions
*How to Parameterize tests
*Parallel testing
*Data Provider
*Invocation Count
*TestNG Listeners

*How to launch a browser?
*Create your first script using Webdriver
*Navigate to URL
*Verify Page title
*get the Page Source 
*Difference between Close & Quit
*Navigate Back & Forward
*Refresh Page
*Other ways of Navigating to a specific Page

*How To Generate Extent Reports
*Log4j2 for logging
*Page Object Model Pattern – Page Factory

*What is Automation Framework?
*Why do we need an Automation Framework?
*Types of Automation Frameworks
*What is Data Driven Framework
*What is Hybrid Framework
*What is Page Object Model Design Pattern with Non-Page Factory (By Locators) with OOP concepts

*What is Jenkins?
*How to install Jenkins?
*Create your first job in Jenkins
*Create Pipeline using Jenkins
*How do integrate Smoke, System, and Regression test in CI/CD pipeline?
*Integrating your project with Jenkins

*How to use Eclipse
*How to run, stop, and pause the Program
*Debugging in Eclipse
*Understanding console output
*Understanding break points and Watch Variables
*Learn to find errors from Problem Windows and Console

*Basics of HTML
*Tags
*Elements
*Attributes
*Forms
*Form Elements
*Introduction to CSS & JavaScript
*JSP
*Servlet
*JDBC
*Web Servers
*Basic design Patterns

*What is Software Testing? Types of Software Testing?
*Challenges in Manual testing
*How does Automation Overcome challenges in Manual testing?
*How do Automation tools work and what Tools for Automation Testing?
*How important is Programming in Automation Testing?
*What is Selenium? What are the components of Selenium?
*What are the Advantages & Disadvantages of Selenium WebDriver?

*Introduction to Java
*Difference between JDK, JRE, and JVM
*Downloading and Installing Java
*Downloading and Installing Eclipse
*What is IDE?
*How to install IDE?
*How to write a Basic Java program?
*Understanding console output
*Java Variables and Data Types
*Java Operators
*Conditional statements – if, if else, switch case
*Loops – while, do while, for
*Jumping statement – break and continue
*Arrays
*String Class
*String methods

*What is Action Class?
*What can we do with Action Class?
*Mouse Hover & Mouse Movement with Action
*Finding Coordinates of a Web Object
*Drag and Drop Action
*Click and SendKeys using Actions Class

Certified SDET Professional course and training by DevLab Alliance is designed in such a way that you can become an SDET Professional in a short span of time.

Certified SDET Professional Training - DevLabs Alliance

*e2e, node_modules, src/app, src/assets, src/environments, index.html, main.ts, polyfills.ts, style.css, angular-cli.json, karma.conf.js, package-lock.json, package.json etc

*What are Collections?
*Collection Classes in Java
*Util Package interfaces
*ArrayList
*LinkedList
*HashSet
*TreeSet
*LinkedHashSet
*HashSet
*Stack
*ArrayDeque
*PriorityQueue
*Iterator

*Session Factory configuration
*Local Session Factory Bean
*Contextual Sessions and Spring Integration

*What is Exception and its types
*Pre Defined Exceptions
*Try-Catch-Finally block
*Multiple & Nested Try Catch block
*Throws vs throw keywords
*Checked and UnChecked Exceptions
*Java Custom/User Defined Exceptions
*User Defined Exceptions examples

*Challenges for Modern Applications
*Motivation for Spring, Spring Architecture
*The Spring Framework

*Examining Dependencies
*Dependency Inversion
*Configuration and Usage of Dependency Injection (DI) in Spring

Integrating Spring with Java EE Web Apps
 *ContextLoaderListener
 *WebApplicationContext
Spring Web MVC Overview
*Capabilities
*Architecture (Front Controller, MVC Pattern)
Spring MVC Basics
*DispatcherServlet, Configuration (@EnableWebMvc, Servlet 3 initialization), mvc *Namespace
*Controllers, @Controller, @RequestMapping (Handler Methods)
*@RequestParam and Parameter Binding
*View Resolvers
*Controller Details, @RequestMapping, @RequestParam, @PathVariable
*Model Data, @ModelAttribute, Model/ModelAndView Classes

*Overview
*Basic tags
*Elements
*Attributes
*Phrase Tags
*Formatting
*Image, text and email Links
*Frames and iframes
*Blocks
*Colour, font and background
*Forms
*Multimedia
*Layouts

*Overview of GIT
*GIT Installation
*Create GIT Account
*GIT Lifecycle
*GIT Integration with Eclipse
*GIT Create
*GIT Clone
*GIT Commit
*GIT Push
*GIT Update
*GIT Delete
*GIT Stash

*Creational design patterns
*Structural design patterns
*Behavioral Design Patterns

*Overview – code-centric Configuration
*@Configuration and @Bean
*Dependency Injection
*Resolving Dependencies on Other Beans
*Injecting Configuration Classes

*Single Responsibility Principle (SRP)
*Open-Closed Principle (OCP)
*Liskov Substitution Principle (LSP)
*Interface Segregation Principle (ISP)
*Dependency Inversion Principle (DIP)

*Value Injection
*Constructor Injection
*Qualifiers / Domain Specific Language (DSL)
*Profiles

*Overview and basics
*Events and Cookies
*Page redirect
*Dialog Box
*Errors and Exceptions
*Form Validation
*Animation
*Debugging

*JSR 330 (@Named) and Spring (@Component) Annotation Styles
*@Named/@Component, @Inject/@Autowired, @Repository, @Service
*Configuring Beans and Autowiring with Annotations

*Modules
*Components
*Templates
*Metadata
*Data binding
*Directives
*Services
*Dependency injection

*18-20 hours of Recorded sessions of Core Java will be provided

*Defining Generic Class
*Bounds on Generics
*Generic Methods
*Do’s and Don’ts in Generics

*Overview of Spring Database Support
*Configuring a DataSource
*Using Spring with Hibernate

*Java Concurrency – Introduction
*Concurrency Evolution
*Thread Safety
*Locks and thread synchronization
*Object vs. Class Level Locking
*UncaughtExceptionHandler
*Java Concurrency Utilities
*Atomic operation

*REST Overview
*Characteristics/Capabilities
*URI Templates
*REST vs SOAP
*REST and Spring MVC
*Spring support for REST
*@RequestMapping/@PathVariable, @RequestBody, @ResponseBody, HTTP *Method Conversion
*Writing RESTful Controllers
*Returning XML and JSON Data
*Client-Side Access to RESTful Services
*Using Spring’s RestTemplate
*Programming Common REST Patterns
*GET: Read
*POST: Create
*PUT: Update
*DELETE: Delete

*What is Immutable class?
*How to create Immutable class in Java?
*Examples to create Immutable class

*Managing Beans
*Inversion of Control / IoC, Dependency Injection / DI
*Configuration Metadata Overview, Configuring Beans (XML)

*Managing the EntityManager (EM)
*Creating a JPA Repository/DAO Bean – @PersistenceUnit, @PersistenceContext

*Installing tomcat
*CAC enabling Tomcat
*Configuring a JDBC database
*Configuring a JNDI database
*Embedding into an application
*Tomcat Virtual Hosts

*Abstraction
*Polymorphism
*Inheritance
*Encapsulation
*Composition
*Aggregation and Association

*Overview of the Spring Container
*ApplicationContext Overview
*API and Usage

*Lambda Expression
*Functional Interface
*Default Methods
*Streams
*Date/Time API Changes

*Bean Scope Defined – Singleton, Prototype, and Other Scopes
*Configuring Scope
*Bean Creation Lifecycle
*Lifecycle Callbacks
*BeanPostProcessor
*Event Handling

DevLabs Alliance comes up with the SDET to Developer Certification Program Training to transform yourself from SDET to Developer.

SDET to Developer Certification Training - DevLabs Alliance

Scripting is the future. Excel at every aspect of Python scripting with DevLabs’s Software Development Engineer in Test (SDET) course. Our course empowers you to gain unbeatable skills in Python programming language and CI/CD pipelines. Elevate your career to reach the heights you once imagined.

What are the roles and responsibilities of SDET?

Want To Know More

“ The hands-on projects helped our team put theory into practice. Thanks to this training, we've achieved seamless collaboration, faster releases, and a more resilient infrastructure. ”