*Introduction
*Describe factors that can affect costs in Azure
*Compare the pricing and total cost of ownership calculators
*Exercise- Estimate workload costs by using the pricing calculator
*Exercise- Compare workload costs using the TCO calculator
*Describe the Azure cost management tool
*Describe the purpose of tags

*Introduction to Microsoft Azure Fundamentals
*Introduction to cloud computing
*What is cloud computing
*Describe the shared responsibility model
*Define cloud models
*Describe the consumption-based model

*Introduction
*Describe the benefits of high availability and scalability in the cloud
*Describe the benefits of reliability and predictability in the cloud
*Describe the benefits of security and governance in the cloud.
*Describe the benefits of manageability in the cloud

*Introduction
*Describe the purpose of Azure blueprints
*Describe the purpose of azure policy
*Describe the purpose of resource locks
*Exercise- Configure a resource look 
*Describe the purpose of the service trust portal

*Introduction
*What is Microsoft Azure
*Get started with Azure accounts
*Exercise - Explore the learn sandbox
*Describe the Azure physical infrastructure 
*Describe Azure management infrastructure 
*Exercise - Create an Azure resource 


*Introduction
*Describe Azure directory services
*Describe Azure authentication methods
*Describe Azure external identities
*Describe Azure conditional access
*Describe Azure role-based access control
*Describe the zero trust model
*Describe defense in-depth 
*Describe Microsoft Defender for cloud

*Introduction
*Describe Azure Virtual Machines
*Exercise - Create an Azure virtual Desktop
*Describe Azure Containers
*Describe Azure functions
*Describe application hosting options 
*Describe Azure Virtual Networking
*Exercise-Configure network access
*Describe Azure Virtual Private Networks
*Describe Azure Express Route
*Describe Azure DNS

*Introduction
*Describe infrastructure as a service
*Describe the Platform as a service 
*Describe Software as a service


*Introduction
*Describe Azure storage accounts
*Describe Azure storage redundancy
*Describe Azure storage services
*Exercise- Create a storage blob
*Identify Azure data migration options
*Identify Azure file movement options

*Introduction
*Describe tools for interacting with Azure
*Describe the purpose of Azure arc
*Describe azure resource manager and azure ARM templates

*Introduction
*Describe Azure service health
*Describe azure monitor

The training is designed to prepare for the AZ-900 Microsoft Azure Fundamentals exam. The course will help you learn Cloud Computing along with its services in Microsoft Azure.

AZ-900 Microsoft Azure Fundamentals Exam Training Course

live

solo

self

*Design a dependency management strategy
*Recommend artifact management tools and practices (Azure Artifacts, npm, Maven, Nuget
*Abstract common packages to enable sharing and reuse
*Inspect codebase to identify code dependencies that can be converted to packages
* Identify and recommend standardized package types and versions across the solution

• Refactor existing build pipelines to implement version strategy that publishes packages

Manage security and compliance

• Inspect open source software packages for security and license compliance to align with corporate standards (e.g., gplv3)

• Configure build pipeline to access package security and license rating (e.g., black duck, white source)

• Configure secure access to package feeds

*Recommend and design system feedback mechanisms
*Design practices to measure end-user satisfaction (e.g., send a smile, app analytics)
*Design processes to capture and analyze user feedback from external sources (e.g., twitter, reddit, help desk)
*Design routing for client application crash report data
*Recommend monitoring tools and technologies
* Recommend system and feature usage tracking tools
*Implement process for routing system feedback to development teams
*Configure crash report integration for client applications
*Develop monitoring and status dashboards
*Implement routing for client application crash report data
*Implement tools to track system usage, feature usage, and flow
* Integrate and configure ticketing systems with development team’s work management system (e.g., it service management connector, servicenow cloud management, app insights work items)
*Optimize feedback mechanisms
*Analyze alerts to establish a baseline
*Analyze telemetry to establish a baseline
*Perform live site reviews and capture feedback for system outages
*Perform ongoing tuning to reduce meaningless or non-actionable alerts

*Design an infrastructure and configuration management strategy
*Analyze existing and future hosting infrastructure
*Analyze existing infrastructure as code (iac) technologies
* Design a strategy for managing technical debt on templates
*Design a strategy for using transient infrastructure for parts of a delivery lifecycle
* Design a strategy to mitigate infrastructure state drift
*Implement Infrastructure as Code (IaC)
* Create nested resource templates
*Manage secrets in resource templates
*Provision azure resources
*Recommend an infrastructure as code (iac) strategy
*Recommend appropriate technologies for configuration management (e.g., arm templates, terraform, chef, puppet, ansible)
*Manage Azure Kubernetes Service infrastructure
*Provision Azure Kubernetes Service (e.g., using ARM templates, CLI)
*Create deployment file for publishing to Azure Kubernetes Service (e.g., kubectl, Helm)
*Develop a scaling plan
*Implement infrastructure compliance and security
*Implement compliance and security scanning
*Prevent drift by using configuration management tools
*Automate configuration management by using powershell desired state configuration (dsc)
*Automate configuration management by using a vm agent with custom script extensions
*Set up an automated pipeline to inspect security and compliance

*Recommend a migration and consolidation strategy for DevOps tools
*Analyze existing artifact (e.g., deployment packages, nuget, maven, npm) and container repositories
*Analyze existing test management tools
*Analyze existing work management tools
*Recommend migration and integration strategies for artifact repositories, source control, test management, and work management
*Design and implement an Agile work management approach
*Identify and recommend project metrics, KPIs, and DevOps measurements (e.g., cycle time, lead time, WIP limit)
*Implement tools and processes to support Agile work management
*Mentor team members on Agile techniques and practices
*Recommend an organization structure that supports scaling Agile practices
*Recommend in-team and cross-team collaboration mechanisms
*Design a quality strategy
*Analyse existing quality environment
*Identify and recommend quality metrics
*Recommend a strategy for feature flag lifecycle
*Recommend a strategy for measuring and managing technical debt
*Recommend changes to team structure to optimize quality
*Recommend performance testing strategy
*Design a secure development process
*Inspect and validate code base for compliance
*Inspect and validate infrastructure for compliance
*Recommend a secure development strategy
*Recommend tools and practices to integrate code security validation (e.g., static code analysis)
*Recommend tools and practices to integrate infrastructure security validation
*Design a tool integration strategy
*Design a license management strategy (e.g., vsts users, concurrent pipelines, test environments, open source software licensing, third-party devops tools and services, package management licensing)
*Design a strategy for end-to-end traceability from work items to working software
*Design a strategy for integrating monitoring and feedback to development teams
*Design an authentication and access strategy
*Design a strategy for integrating on-premises and cloud resources

*Manage code quality and security policies
* Monitor code quality
* Configure build to report on code coverage
* Manage automated test quality
* Manage test suites and categories
*Monitor quality of tests
* Integrate security analysis tools (e.g., SonarQube, White Source Bolt, Open Web Application Security Project)
*Implement a container build strategy
*Create deployable images (e.g., docker, hub, azure container registry)
*Analyze and integrate Docker multi-stage builds
*Implement a build strategy
*Design build triggers, tools, integrations, and workflow
*Implement a hybrid build process
* Implement multi-agent builds
*Recommend build tools and configuration (e.g. Azure pipelines, jenkins)
*Set up an automated build workflow

*Design a release strategy
*Recommend release tools
*Identify and recommend release approvals and gates
*Recommend strategy for measuring quality of release and release process
*Recommend strategy for release notes and documentation
*Select appropriate deployment patter
*Set up a release management workflow
*Automate inspection of health signals for release approvals by using release gates
*Configure automated integration and functional test execution
*Create a release pipeline (e.g., azure kubernetes service, service fabric, webapp)
*Create multi-phase release pipelines
*Integrate secrets with release pipeline
*Provision and configure environments
*Manage and modularize tasks and templates (e.g., task and variable groups)
*Implement an appropriate deployment pattern
* Implement blue-green deployments
* Implement canary deployments
* Implement progressive exposure deployments
* Scale a release pipeline to deploy to multiple endpoints (e.g., deployment groups, azure kubernetes Service, Service Fabric

*Design a version control strategy
*Recommend branching models
*Recommend version control systems
*Recommend code flow strategy
*Implement and integrate source control
* Integrate external source control
* Integrate source control into third-party continuous integration and continuous deployment (CI/CD) systems
*Implement and manage build infrastructure
* Implement private and hosted agents
* Integrate third party build systems
* Recommend strategy for concurrent pipelines
*Manage Azure pipeline configuration (e.g., agent queues, service endpoints, pools, webhooks)
*Implement code flow
*Implement pull request strategies
* Implement branch and fork strategies
*Configure branch policies
*Implement a mobile DevOps strategy
*Manage mobile target device sets and distribution groups
*Manage target ui test device sets
*Provision tester devices for deployment
*Create public and private distribution groups
*Managing application configuration and secrets
* Implement a secure and compliant development process
*Implement general (non-secret) configuration data
*Manage secrets, tokens, and certificates
*Implement applications configurations (e.g., web app, azure kubernetes service, containers
*Implement secrets management (e.g., web app, azure kubernetes service, containers, azure key vault)
* Implement tools for managing security and compliance in the pipeline

DevLabs Alliance brings you a comprehensive Microsoft Azure DevOps Solutions certification course AZ-400 that combines people, processes, and technologies.

AZ-400: Microsoft Azure DevOps Solutions - DevLabs Alliance

*Develop Azure Infrastructure as a Service compute solution

*Implement solutions that use virtual machines (VM)

* Provision VMs

* Create ARM templates

* Configure Azure Disk Encryption for VMs

*Implement batch jobs by using Azure Batch Services

* Manage batch jobs by using Batch Service API

* Run a batch job by using Azure CLI, Azure portal, and other tools

* Write code to run an Azure Batch Services batch job

*Create containerized solutions

* Create an Azure Managed Kubernetes Service (AKS) cluster

* Create container images for solutions

* Publish an image to the Azure Container Registry

* Run containers by using Azure Container Instance or AKS

*Develop an App Service Logic App

* Create a Logic App

* Create a custom connector for Logic Apps

* Create a custom template for Logic Apps

*Integrate Azure Search within solutions

* Create an Azure Search index

* Import searchable data

* Query the Azure Search index

* Implement cognitive search

*Implement API Management

* Establish API Gateways

* Create an APIM instance

* Configure authentication for APIs

* Define policies for APIs

*Develop event-based solutions

* Implement solutions that use Azure Event Grid

* Implement solutions that use Azure Notification Hubs

* Implement solutions that use Azure Event Hub

*Develop message-based solutions

* Implement solutions that use Azure Service Bus

* Implement solutions that use Azure Queue Storage queues

*Develop code to support scalability of apps and services

* Implement auto scaling rules and patterns (schedule, operational/system metrics, singleton applications)

* Implement code that handles transient faults

* Implement AKS scaling strategies

*Integrate caching and content delivery within solutions

* Store and retrieve data in Azure Redis cache

* Develop code to implement CDN in solutions

* Invalidate cache content(CDN or Redis)

*Instrument solutions to support monitoring and logging

* Configure instrumentation in an app or service by using Application Insights

* Analyze and troubleshoot solutions by using Azure Monitor

* Implement Application Insights Web Test and Alerts

*Develop solutions that use storage tables

* Design and implement policies for tables

* Query table storage by using code

* Implement partitioning schemes

*Develop solutions that use Cosmos DB storage

* Create, read, update, and delete data by using appropriate APIs

* Implement partitioning schemes

* Set the appropriate consistency level for operations

*Develop solutions that use a relational database

* Provision and configure relational databases

* Configure elastic pools for Azure SQL Database

* Create, read, update, and delete data tables by using code

* Provision and configure Azure SQL Database serverless instances

* Provision and configure Azure SQL and Azure PostgreSQL Hyperscale instances

*Develop solutions that use blob storage

* Move items in Blob storage between storage accounts or containers

* Set and retrieve properties and metadata

* Implement blob leasing

* Implement data archiving and retention

* Implement Geo Zone Redundant storage

*Create Azure App Service Web Apps

* Create an Azure App Service background task by using web jobs

* Enable diagnostics logging

* Create an Azure Web App for containers

* Monitor service health by using Azure Monitor

*Create Azure App Service mobile apps

* Add push notifications for mobile apps

* Enable offline sync for mobile app

* Implement a remote instrumentation strategy for mobile devices

*Create Azure App Service API apps

* Create an Azure App Service API app

* Create documentation for the API by using open source and other tools

*Implement Azure functions

* Implement input and output bindings for a function

* Implement function triggers by using data operations, timers, and web hooks

* Implement Azure Durable Functions

* Create Azure Function apps by using Visual Studio

* Implement Python Azure functions

*Implement authentication

* Implement authentication by using certificates, forms-based authentication, or tokens

* Implement multi-factor or Windows authentication by using Azure AD

* Implement oauth2 authentication

* Implement Managed identities/Service Principal authentication

* Implement Microsoft identity platform

*Implement access control

* Implement CBAC (Claims-Based Access Control) authorization

* Implement RBAC (Role-Based Access Control) authorization

* Create shared access signatures

*Implement secure data solutions

* Encrypt and decrypt data at rest and in transit

* Create, read, update, and delete keys, secrets, and certificates by using the key vault API

DevLabs Alliance brings you a comprehensive Microsoft Certified Azure Developer Associate certification course AZ-203.

AZ-203: Developing Solutions for Microsoft Azure - DevLabs Alliance

Cloud technology is the future. Thus, getting your hands on one of the most in-demand cloud service tools like Azure can boost the pace of your career rapidly. Join us today at DevLabs and get a professional learning experience of Microsoft’s Azure cloud platform. Learn to master cloud services and become a professional at it.

Azure

*Introduction to Swarm & Advantages
*How to create a swarm (cluster of nodes)
*How to add nodes to swarm
*How to deploy services/containers to swarm
*Docker stack deploy
*Introduction to UCP (universal control pane)

*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

*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

*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

*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

*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

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

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

*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

*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

*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
*Download Docker Compose

*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

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

*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

*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

*Spin up multiple containers with Single command
*Docker Compose and the docker-compose.yml File
*Running Compose Commands
*Adding Image Building to Compose Files

*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
*Centralized & Distributed Version Control System
*Anatomy of GIT
*GIT Features
*Git Commands
*3-Tree Architecture
*GITHUB Projects
*Git Repositories
*GITHUB Management and Commands
*Clone
*Checkout
*Commit
*Push
*Merge
*Pull Request
*Fork/Pull
*Git Branches
*Remote branch
*Local branch
*Advantages of Git

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

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

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

*Monitoring the Cluster Components
*Monitoring the Applications Running within a Cluster
*Managing Cluster Component Logs
*Managing Application Logs

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

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

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

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

*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

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

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

*What is Kubernetes & why
*Kubernetes Terminology
*Kick start Kubernetes
*Comparison with Docker Swarm

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 Course - DevLabs Alliance

*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

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

*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

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

*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

*Introduction to Docker Swarm
*Docker Swarm vs Kubernetes

*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

*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

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

*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

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

*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

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

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

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

*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

*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

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

*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

*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

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

*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

*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

*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

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

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

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

*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

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

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

*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

*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

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

*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

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

*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

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

*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

*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

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

*Automate common Linux system administration tasks with Ansible.

*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

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

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

*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

*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

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

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

*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

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

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

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

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

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

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

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

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

*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

The Certified DevOps Foundation Certification course and training 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

*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

*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

*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

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

*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

*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

*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

*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

*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

*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

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

*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

*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 to MySQL
*Installation
*Create Database
*Drop Database
*Select Database
*Create Table
*Insert Query
*Select Query
*Delete Query
*Joins and more queries

*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

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

*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

*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

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

*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


*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

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

*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

*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

*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

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 Course and Training - DevLabs Alliance

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

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

*What is Sprint Boot?
*Why Spring Boot
*Advantages of Spring Boot

*Introduction to Design Patterns
*Model View and Controller – MVC
*Singleton Design Pattern

*Basics of HTML
*Tags
*Elements
*Attributes
*Forms
*Form Elements
*Introduction to CSS & JavaScript

*Introduction to Spring JDBC
*JDBC Template
*Data Access/ Integration Modules
*How to make connections

*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

*Servlet Overview
*Servlets Architecture
*Servlets Life Cycle
*doGet and doPost Methods

*Introduction to Web Servers
*How to deploy application in Server
*Debugging
*Logging

*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
*Validating the REST API responses

*What is Automation Framework?
*Why do we need Automation Framework?
*Types of Automation Frameworks
*Linear Scripting Framework
*Modular Testing Framework
*Data Driven Testing Framework
*Keyword Driven Testing Framework
*Hybrid Testing Framework
*Behaviour Driven Development Framework
*How to design Automation Framework
*Architecture of Automation Framework

*JSP Overview
*Advantages of JSP
*JSP Lifecycle
*Scripting elements
*JSP Implicit Objects
*JSP Page Directive Attributes
*JSP Directives
*JSP Actions

Learn about Automation Frameworks, API, and Web Development with Certified SDET Advanced Course and Training.  Get in-depth knowledge of Jenkins Integration with Cloud with extensive exercises.

Certified SDET Advanced Course and Training - DevLabs Alliance

*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

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

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

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

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

*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

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

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

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

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

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

*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

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

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

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

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

SDET to Developer Certification Program - 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.