*What is Automation Framework
*Why we need Automation Framework
*Type of Automation Framework
*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

*Introduction to web services
*Type of Web services
*SOAP
*REST
*How to design Web services
*Web Services Architecture
*How to Test Web Services
*Testing Framework for Web Services
*Automation Framework Design and Implementation

*Introduction to Jenkins
*How to configure cloud in Jenkins
*How to execute selenium scripts
*Parallel execution setup from Jenkins
*Automated Reporting

*What is cloud
*Type of Cloud
*Need of Cloud
*Parallel Execution in Cloud
*Cross Browser testing
*What is Continuous testing?

*What is code coverage
*Tools used for Code coverage
*How to calculate code coverage
*Why code coverage is important
*Code Coverage Metrix
*Most Popular tools
*Sonar tool implementation

*What is security Testing
*Why security is important
*Types of security testing
*Most popular security testing tool
*How to scan the application code
*SAST vs DAST vs IAST

*Page Object Pattern
*Advanced Page Object Pattern
*Facade Design Pattern
*Singleton Design Pattern
*Fluent Page Object Pattern.
*IoC Container and Page Objects
*Strategy Design Pattern

*What is Design Pattern
*Where to apply Design Pattern
*Type of Design Patterns
*Creational Design Pattern
*Structural Design Pattern
*Behavioural Design Pattern
*Advantages of Design patterns

SDET Architect Certification course and training is designed by industry practitioners to enable you to fit you in this most demanding market.

Certified SDET Architect Training and Course - DevLabs Alliance

live

self

solo

*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

*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

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

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

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

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

*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

*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

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

*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

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

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

*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

*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

*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

*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

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


*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

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

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

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

*Introduction to Selenium WebDriver
*How to launch Browsers?
*Architecture of Webdriver
*Methods in WebDriver
*Create your first script using Webdriver

*Launch Browser
*Navigate to URL
*Verify Page Title
*Close Browser
*Back and Forward
*Refresh page

*Installing Eclipse
*Eclipse IDE setup
*Set Up a project from scratch

*What is JUnit?
*How to install JUnit?
*JUnit Annotations – @BeforeClass, @Before, @Test, etc.
*JUnit Assert
*JUnit test suite
*What is TestNG?
*How to install TestNG?
*Benefits and features of TestNG
*Annotations in TestNG – @Test, @BeforeTest, @AfterTest, @BeforeSuite, @Parameters
*Testng.xml
*Implementing JUnit & TestNG in your code

*Implicit and Explicit Waits
*Expected Conditions with Waits
*Page Load Timeout & Set Script Timeout property
*Implement wait by Thread Sleep
*Wait Until Conditions
*Handle Ajax based applications
*Handle Simple, Confirmation & Prompt Alert
*Difference between Window Handle & Handles

*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 Glue code/Step Definitions?
*Data Driven Testing in Cucumber
*What are Cucumber Tags?
*Background in Cucumber
*Data Tables in Cucumber

*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

*What is Maven?
*Features of Maven
*Why to use Maven
*Installing & Running Maven
*Using Maven in your project

*Difference between Find Element & find Elements
*Enter & Clear Text from Input field
*Click Action
*Input fields, buttons & links
*What are Locators?
*Introduction to HTML basics
*Identify ID, Name, Xpath, CSS from HTML Code
*Difference between Absolute & Complete Xpath
*Web Element
*How to use Firebug and Firefox plugin
*Get your Xpath
*Select and UnSelect Checkbox
*Handle Drop Down Scenarios –Select/DeSelect
*Select and DeSelect Radio Button
*Validate Drop Down Values

*Handling Dynamic Web Tables
*Introduction to Selenium Grid
*How to capture Screenshots?
*SSL Certificates Error Handling
*Execute Javascript Based code for Selenium Webdriver
*Launching different browsers using Webdriver
*Download specific exe file for multiple Browser
*Launching IE
*Challenges with IE Browser
*IE driver server and path settings
*Launching Chrome
*Chrome server and path settings

*Introduction to Java
*JDK, JRE and JVM
*Operators in Java
*Data Type and Variable
*Conditional & Decision Making
*Java Comments
*Introduction to Classes
*Constructor
*Methods in Java
*Inheritance
*Method Overloading and *Overriding
*Final Keyword
*Interface
*Java String
*Packages
*Wrapper Classes
*Exception Handling
*List
*Set
*Map
*Introduction to Thread

*What is ATDD(Acceptance Test Driven Development)?
*What tools are required to implement ATDD?
*Introduction to Cucumber

With Certified SDET Foundation training courses you will become skilled professionals who are adept in the area of QA Engineering as well as of Software Development.

Certified SDET Foundation Training Course - DevLabs Alliance

*Introduction Accessing values in dictionaries
*Working with dictionaries
*Properties
*Functions
*Defining a function
*Calling a function
*Types of functions
*Function Arguments
*Anonymous functions
*Global and local variables

*Logging with python selenium
*Logging in python
*Configuring logging
*Logging with selenium python
*Logging to console with python
*Print vs. Logging

*What is PyBehave framework
*Tests in Behave python
*What is Feature
*What is Step definition
*How to setup runner class

*Web element operations in selenium python
*TextBox
*ListBox
*Links
*Check Box
*Radi*Button
*HTML Tables
*Calendars

*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 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 python Pytest framework
*Tests in Pytest python.
*Setup.
*Teardown.
*Skipping tests and expected failures

*Introduction
*Accessing Tuples
*Operations
*Working
*Functions and Methods

*Developer tool in chrome
*Developer tool in firefox

*Loading tests to suite and running tests in python selenium
*Create test suite

*Csv files in python
*Csv with python selenium
*Reading a csv file with header
*Read the urls from the csv file
*Writing a csv file in python selenium
*Writing to a file with dictwriter in python selenium
*Read & write csv files with custom del

*What is Automation Framework?
*Why d*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

*Introduction
*Accessing list and sets
*Operations
*Working with lists and sets
*Function and Methods

*What is python unittest framework
*Things to remember while writing unit tests
*Tests in unittest python
*Setup, Teardown
*Setupclass, Teardownclass
*Setupmodule & teardownmodule
*Skipping tests and expected failures

*Break
*Continue
*Pass
*String Manipulation (Key for Interview)
*Accessing Strings
*Basic Operations
*String slices
*Function and Methods

*Open browser in selenium python
*Close and quit browsers
*Open webpage in selenium python
*Browser size in selenium python
*Webpage properties
*Navigation commands in selenium python

*If
*If- else
*Nested if-else
*Looping
*For
*While
*Nested loops

*Install python
*Install selenium bindings
*Install pydev with eclipse
*Console on pydev
*Install python
*Install selenium bindings
*Install pydev with eclipse
*Console on pydev

*Dropdowns in python selenium | select
*Dropdowns in python selenium | list

*Importing module
*Math module
*Random module
*Packages
*Composition
*Input-Output
*Printing on screen
*Reading data from keyboard
*Opening and closing file
*Reading and writing files
*Functions

*Iframes
*Handling multiple windows
*Handling web tables
*Screenshots
*Mouse and keyboard Actions
*Exceptions
*Handling Files
*Java Script Executor

*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

*Attributes
*Inheritance
*Overloading
*Overriding
*Data hiding
*Exception Handling
*Exception
*Except clause
*Try ? finally clause
*User Defined Exceptions

*Excel spreadsheets with python
*Openpyxl module with python selenium
*Read excel using openpyxl with python selenium
*Get all values of a specific column
*Write excel file using openpyxl in python selenium

*Configuring Allure Report
*Interview Questions

*History
*Features
*Setting up path
*Working with Python
*Basic Syntax
*Variable and Data Types
*Operator

*Web element in python
*The priority of locators in selenium
*Find element by id
*Find element by name.
*Find element by tag name
*Find element by linked Text/Partial Linked text.
*Find element by classname.
*Find element by xpath.
*Find element by css selector.
*Find elements
*Find element and find elements.
*Excellent & reliable selenium python locator

*Assertions in unittest python with selenium

Enrolling into SDET with Python Training Professional Course to become master in using SDET with python. Learn various tools such as Unittest, Pytest, PyBehave, GitHub, Jenkins, cucumber, XPath, etc


Certified SDET Professional – Python Training Course - 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

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

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

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

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

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

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

*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

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

*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

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

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

Certified SDET Advanced Training Course - DevLabs Alliance

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

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

*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

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

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

*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

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

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

*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

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

*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

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

*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

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.

SDET

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

*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

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

*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

*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

*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

*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

*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

*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

*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

*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

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

*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

*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

*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

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

*Automate common Linux system administration tasks with Ansible.

*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

*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

*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

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

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

*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

*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

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

*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

*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

*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

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

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

*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

*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

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

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

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

*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

*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

*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

*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

*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

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

DevOps Advance Certification Training Course

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.

Key Highlights

Who Should Attend?

Why Attend This Demo?

Register Now for the Free Demo Session!