Module 2: Basic Control Techniques
Kinematic bicycle model and its application in control design Pure
Module 1: Introduction to Motion Control
Role of motion control in autonomous driving Longitudinal and lateral
Module 9: Security and Update Management
Security concepts and implementation in Adaptive AUTOSAR Authentication, authorization, and
Module 8: Persistency and Diagnostics
Persistency module for data storage and management Diagnostics Management for
Module 7: AUTOSAR Manifest
Structure and components of the AUTOSAR Manifest Defining application dependencies
Module 6: Communication Management
Communication Management architecture and functions Service discovery and configuration management
Module 5: SOME/IP Communication
Overview of SOME/IP communication protocol Service discovery and client-server communication
Module 4: Execution Management
Process lifecycle management Resource allocation and management Health monitoring and
Module 3: Adaptive AUTOSAR Applications
Application structure and manifest files Managing processes and threads Inter-process
Module 2: Adaptive AUTOSAR Methodology
Service-Oriented Architecture (SOA) concepts Application design and modeling Understanding the
Module 1: Introduction to Adaptive AUTOSAR
Adaptive AUTOSAR architecture and concepts Comparison with Classic AUTOSAR Use
Module 7: Code Generation and Integration
Generating AUTOSAR-compliant code from Simulink models Configuring code generation settings
Module 6: Software Architecture Modeling with System Composer
Introduction to System Composer for software architecture modeling Creating components,
Module 5: Variant Management in AUTOSAR Applications
Managing software variations in AUTOSAR Using pre-compile options and configuration
Module 4: AUTOSAR Modeling Styles and Patterns
Best practices for AUTOSAR modeling Atomic and composite software components
Module 3: Modeling AUTOSAR Components in Simulink
Creating AUTOSAR components, runnables, and events Modeling components, ports, and
Module 2: AUTOSAR Design Workflows
Bottom-up, top-down, and round-trip design approaches Selecting suitable workflows for
Module 1: Introduction to AUTOSAR and Simulink
Overview of AUTOSAR architecture and components Benefits of using Simulink
Module 7: AUTOSAR Memory Stack
Understanding memory management in AUTOSAR Non-volatile memory management (NVRAM) Flash
Module 6: AUTOSAR Crypto Stack
Cryptographic services and secure communication in AUTOSAR Data protection using
Module 5: AUTOSAR Diagnostic Stack (Diag)
Introduction to the diagnostic stack architecture UDS and OBD diagnostic
Module 4: AUTOSAR Communication Stack (Com)
Overview of the communication stack architecture Signal routing and data
Module 3: AUTOSAR Operating System (OS)
Features and architecture of AUTOSAR OS Tasks, scheduling, and resource
Module 2: AUTOSAR Runtime Environment (RTE)
Understanding the RTE architecture and functionalities Communication mechanisms: Sender-Receiver and
Module 1: Introduction to AUTOSAR Architecture
Overview of AUTOSAR layered software architecture Application Layer, RTE, and
Module 6: MCAL Integration and Debugging
Integrating MCAL with the AUTOSAR Runtime Environment (RTE) Debugging and
Module 5: Implementing UART and I2C as Complex Device Drivers (CDD)
Concept of Complex Device Drivers (CDD) in AUTOSAR UART implementation:
Module 4: Core MCAL Modules
PORT Configuration: Input, output, alternate functions, and interrupts DIO: Digital
Module 3: MCAL Configuration and Code Generation
Using AUTOSAR configuration tools for MCAL setup Setting configuration parameters
Module 2: AUTOSAR MCAL Documentation
Understanding AUTOSAR MCAL SRS and SWS documents Extracting and applying
Module 1: Introduction to AUTOSAR MCAL
AUTOSAR architecture and software structure Overview of MCAL and its
Module 7: Testing and Security
Introduction to Compatibility Test Suite (CTS) and Vendor Test Suite
Module 6: CAR API and Application Development
Overview of the CAR API and its applications Accessing vehicle
Module 5: Hardware Abstraction Layer (HAL)
Understanding HAL architecture and types (legacy, binderized) Implementing HAL modules
Module 4: Android BSP Development
Introduction to Board Support Package (BSP) concepts Porting Android to
Module 3: Android Framework and Build System
Android application components: Activities, Services, Broadcast Receivers, Content Providers User
Module 2: Android OS Fundamentals
Linux kernel functions in Android Android boot process and initialization
Module 1: Introduction to Android Automotive OS
Overview of Android and its role in the automotive industry
Module 7: Debugging and Troubleshooting
Debugging kernel code using printk, kdump, and kgdb Analyzing kernel
Module 6: Kernel Features and Internals
Process and thread management in Linux kernel Inter-process communication using
Module 5: Network Device Drivers
Overview of network stack and driver interaction Introduction to net_device
Module 4: Block Device Drivers
Understanding block device driver framework Request queue and I/O scheduling
Module 3: Character Device Drivers
Character device driver framework and file operations Implementing open, read,
Module 2: Kernel Modules
Understanding kernel modules and their benefits Building and loading kernel
Module 1: Introduction to Linux Kernel
Overview of Linux kernel architecture and components Kernel source code
Module 7: Application Development and Deployment
Cross-compiling applications for embedded Linux Using libraries and frameworks for
Module 6: Introduction to Xen Hypervisor
Basics of virtualization and its advantages Understanding Xen hypervisor architecture
Module 5: Yocto Project
Overview of the Yocto Project and its components Understanding the
Module 4: Root File System
Introduction to root file system and its structure Role of
Module 3: Bootloaders and Boot Process
Understanding bootloader concepts and types Introduction to U-Boot and GRUB
Module 2: Building the Linux Kernel
Downloading and understanding Linux kernel source code Kernel configuration using
Module 1: Introduction to Embedded Linux
Overview of embedded systems and their applications Benefits of using
Module 9: Building an Automotive Infotainment Application
End-to-end project to design a simplified automotive infotainment application Implementing
Module 8: Testing and Debugging
Introduction to Qt Test framework for unit testing Writing and
Module 7: Qt for Mobile Development
Building and deploying Qt applications for mobile platforms like Android
Module 6: Concurrency and Multithreading
Basics of concurrency and multithreading in Qt Using QThread and
Module 5: Qt Graphics and Animation
Introduction to Qt’s graphics framework using QPainter and QGraphicsView Drawing
Module 4: Model/View Programming
Introduction to Model/View architecture in Qt Using Qt's model classes
Module 3: Qt Quick and QML
Introduction to Qt Quick and QML (Qt Meta-Object Language) Understanding
Module 2: Qt Widgets and Layouts
Introduction to Qt Widgets and their properties Common Qt Widgets
Module 1: Introduction to Qt and Qt Creator
Overview of the Qt framework and architecture Qt modules for
Module 6: Motion Planning for Autonomous Driving
Addressing challenges specific to autonomous driving motion planning Managing dynamic
Module 5: Rapidly-exploring Random Trees (RRT and RRT*)
Introduction to RRT for exploration and pathfinding Understanding the improvements
Module 4: Optimization-Based Motion Planning
Formulating motion planning as an optimization problem Defining objective functions
Module 3: Motion Planning with Potential Fields
Understanding potential field-based motion planning concepts Using attractive and repulsive
Module 2: Path Planning Techniques
Graph-based search algorithms: Dijkstra’s algorithm for shortest path finding A*
Module 1: Introduction to Motion Planning
Understanding the role of motion planning in autonomous driving Difference
Module 6: Particle Filter
Understanding particle filter algorithms for localization Importance sampling and resampling
Module 5: Lidar Localization
Point cloud processing techniques for lidar localization Point cloud registration
Module 4: Extended Kalman Filter (EKF) and Unscented Kalman Filter (UKF)
Managing nonlinearity using EKF and UKF EKF linearization and Jacobian
Module 3: Kalman Filter (KF)
Understanding the Linear Kalman Filter algorithm State prediction and measurement
Module 2: State Estimation Techniques
Introduction to Bayesian filtering for state estimation Markov process and
Module 1: Introduction to Localization and Coordinate Systems
Importance of localization in autonomous driving Global and local localization
Module 7: Perception Simulation in CARLA
Implementing perception algorithms in ROS within CARLA Evaluating perception algorithms
Module 6: ROS-CARLA Bridge
Overview of Robot Operating System (ROS) Establishing a ROS-CARLA bridge
Module 5: Camera and Lidar Systems
Camera models and image formation Lens distortion and calibration techniques
Module 4: Static and Dynamic Object Detection
Object detection using traditional methods like HOG and Haar features
Module 3: Scene Detection and Understanding
Semantic segmentation and scene labeling Deep learning for scene understanding
Module 2: Lane Detection
Camera calibration and image rectification Color space transformations and edge
Module 1: Introduction to Perception for Autonomous Driving
Role of perception in autonomous driving systems Object detection, tracking,
Module 6: Deployment and Optimization
Deploying deep learning models on Jetson Nano Model optimization techniques
Module 5: YOLO for Object Detection
Introduction to YOLO (You Only Look Once) and its versions
Module 4: OpenCV for Computer Vision
Basics of OpenCV for image and video processing Image manipulation,
Module 3: Convolutional Neural Networks (CNN)
Introduction to CNN architecture: convolutional layers, pooling layers, fully connected
Module 2: Artificial Neural Networks (ANN)
ANN architecture: neurons, layers, and activation functions Perceptron and multilayer
Module 1: Introduction to Deep Learning for Autonomous Driving
Deep learning fundamentals and applications in autonomous driving Key perception
Module 7: Mathematical Operations for Autonomous Driving
Introduction to NumPy for numerical computing Array creation and manipulation
Module 6: Functions and Modules in Python
Defining and using functions Function arguments and return values Understanding
Module 5: Data Structures in Python
Lists, tuples, dictionaries, and sets List comprehensions and their applications
Module 4: Introduction to Python
Setting up the Python environment Basic syntax, variables, and data
Module 3: C++ Standard Template Library (STL) for Embedded Systems
STL containers: array, vector, deque, list Choosing containers for embedded
Module 2: Template Metaprogramming (TMP)
Function and class templates Template specialization and partial specialization Compile-time
Module 1: Modern C++ Fundamentals and Resource Management
Overview of C++11/14/17/20 features Auto keyword, range-based for loops, uniform
Module 6: Integration and System Testing, Debugging
Performing top-down and bottom-up integration testing Developing stubs and drivers
Module 5: Code Coverage Analysis
Understanding code coverage metrics: statement, branch, and path coverage Using
Module 4: Unit Testing with Cmocka
Introduction to Cmocka and its features Writing unit tests using
Module 3: Test Case Design and Development
Designing test cases using black-box and white-box techniques Developing test
Module 2: Test Planning and Requirements Analysis
Developing test strategies and planning test environments Resource allocation, risk
Module 1: Introduction to Embedded Software Testing
Importance of software testing in embedded systems Types of software
Module 5: FreeRTOS on Linux and Debugging
Running FreeRTOS using the POSIX port on a Linux host
Module 4: FreeRTOS Porting and Integration with STM32
Understanding FreeRTOS porting process for STM32 Cortex-M4 Configuring tick interrupts
Module 3: Inter-Task Communication and Synchronization
Using queues for message passing with xQueueCreate(), xQueueSend(), and xQueueReceive()
Module 2: FreeRTOS Fundamentals and Task Management
Task creation and management using FreeRTOS Task priorities, states, and
Module 1: Introduction to RTOS and FreeRTOS
Real-time system concepts and characteristics Differences between RTOS and general-purpose
Module 7: ARM Bare-metal Programming
Writing bare-metal programs using C and QEMU emulator Understanding ARM
Module 6: Analog-to-Digital Converter (ADC) and Debugging
ADC resolution, conversion modes, and DMA integration Reading analog sensor
Module 5: I2C and SPI Communication
I2C protocol, addressing, and configuration using HAL API Interfacing with
Module 4: Serial Communication (UART)
UART protocol and configuration Transmitting and receiving data using UART
Module 3: Timers and Interrupts
Timer modes: basic timer, general-purpose timer, PWM Timer configuration using
Module 2: STM32 HAL Library and GPIO
Introduction to STM32 HAL library and its architecture GPIO configuration
Module 1: Introduction to ARM Cortex-M4 with STM32 Platform
ARM Cortex-M4 architecture, registers, and memory map Interrupts and exception
Module 4: Concurrency and Asynchronous Programming
Managing Threads with std::thread, std::jthread, and Synchronization Primitives Implementing Mutexes,
Module 3: C++ Standard Template Library (STL) for Embedded
Efficient Use of STL Containers (std::array, std::vector, std::deque, std::list) Evaluating
Module 2: Template Metaprogramming (TMP)
Introduction to Function and Class Templates Specialization and Partial Specialization
Module 1: Modern C++ Fundamentals and Resource Management
Overview of C++11, C++14, C++17, and C++20 Features Use of
Module 6: Advanced Topics in Powertrain Simulation
Thermal modeling of EV components for heat management Simulation of
Module 5: Powertrain Simulation and Analysis
Perform simulations using standard driving cycles (e.g., WLTP, NEDC) Analyze
Module 4: Dynamic Powertrain Modeling
Dynamic modeling of key EV components: Battery dynamics: internal resistance
Module 3: Transmission Modeling
Single-speed and multi-speed transmission models for EVs Modeling gear-shifting mechanisms
Module 2: Quasi-Static Powertrain Modeling
Quasi-static modeling approach for EV powertrains Battery performance modeling: voltage,
Module 1: Introduction to EV Powertrains
Overview of EV powertrain components: battery, motor, power electronics, transmission
Module 6: Motor Control System Design and Simulation
Sensor Selection and Control Loop Tuning. Stability Analysis in Motor
Module 5: Brushless DC (BLDC) Motor Control
Overview of BLDC Motor Construction and Operation. Commutation Techniques for
Module 4: Field-Oriented Control (FOC)
Understanding the principles of FOC for AC motors. Coordinate transformations:
Module 3: AC Motor Fundamentals
Operation principles of Induction Motors. Permanent Magnet Synchronous Motors (PMSM):
Module 2: Inverter Topologies for EVs
Advanced inverter topologies: Multilevel inverters: NPC, Cascaded H-Bridge Matrix converters
Module 1: Introduction to Inverters and Motor Drives
Role of inverters in electric vehicles. Overview of power semiconductor
Module 7: Safety and Regulations
Overview of EV Charging Safety Standards and Regulations. Ensuring Electrical
Module 6: Charging Methods and Energy Consumption
Impact of Charging Methods on Battery Life and Performance. Optimizing
Module 5: EV Charging Management Software
Scheduling and Load Balancing Algorithms. User Authentication and Billing Systems.
Module 4: Wireless Charging for EVs
Principles of Inductive Power Transfer (IPT). Overview of Wireless Charging
Module 3: EV Charging Station Design
Key Components of a Charging Station: Power Supply Charger Unit
Module 2: EV Charger Types and Technologies
Level 1, Level 2, and DC fast chargers: Characteristics and
Module 1: Introduction to EV Charging
Role of charging infrastructure in EV adoption. Overview of conductive
Module 6: Battery Management Systems (BMS)
Overview of BMS architecture and functionalities: Cell balancing Temperature monitoring
Module 5: State of Health (SOH) Estimation
Understanding SOH estimation and its importance. Factors influencing battery degradation
Module 4: State of Charge (SOC) Estimation
Importance of SOC estimation in BMS. Coulomb counting method and
Module 3: Battery Modeling and Simulation
Understanding equivalent circuit models for battery simulation. Parameter identification and
Module 2: Battery Chemistries and Characteristics
Detailed analysis of various battery chemistries: Lithium-ion (Li-ion): LFP, NMC,
Module 1: Introduction to Energy Storage for EVs
Role of energy storage systems in electric vehicles. Overview of
Module 7: Environmental Impact and Future Trends
Environmental benefits of EVs and HEVs Life cycle assessment and
Module 6: Hybrid Electric Vehicle (HEV) Configurations
Architecture and operation of: Series HEVs Parallel HEVs Series-Parallel HEVs
Module 5: EV and HEV Charging Systems
Overview of charging infrastructure and standards Types of charging: AC
Module 4: Batteries and Battery Management Systems (BMS)
Battery chemistries: Lithium-ion, Nickel-Metal Hydride, Lead-Acid Battery characteristics: Voltage, Capacity,
Module 3: Electric Motors and Drives
Types of motors used in EVs and HEVs: DC Motors,
Module 2: EV and HEV Architectures
In-depth study of EV and HEV architectures Components: Battery, Motor,
Module 1: Introduction to Electrified Transportation
History and evolution of electric vehicles Environmental and economic motivations
Module 13: Advanced Software Development for Embedded Systems
Understanding Object File Formats (ABI) Differences between Relocatable and Executable
Module 12: Advanced Data Representation and Manipulation
Memory Layout of Structures (Aligned vs Unaligned) Structure Padding and
Module 11: Advanced Concepts – Pointers and Type Qualifiers
Understanding Volatile, Restrict, and Const Qualifiers Pointer Arithmetic and Memory
Module 10: Advanced C Programming – Memory, Optimization, and Preprocessing
C Memory Organization Overview of AUTOSAR Memmap C Compiler Optimization
Module 9: Development and Compilation in Linux
Setting up Linux in VM Machines Understanding Native vs Cross
Module 8: Command Line Arguments and File Handling
Understanding argc and argv File Operations: Opening, Closing, Reading, and
Module 7: Structures and Unions
Introduction to Structures and Unions Declaration, Array of Structures, and
Module 6: Arrays and Strings
Working with Single, Multidimensional, and Flexible Arrays Pointer-based Array Manipulation
Module 5: Storage Classes
Overview of Storage Classes: Automatic, Static, Register, and Extern Updates
Module 4: Pointers
Introduction and applications of Pointers Call by Value vs Call
Module 3: Functions in C
Function Significance and Scope Concept of Recursion and its applications
Module 2: C Operators and Control Statements
Arithmetic, Relational & Logical Operators Bitwise and Special Operators Operator
Module 1: Introduction to C Programming
Background and importance of C programming in embedded systems Setting
In which languages does AWS Skill Builder support?
AWS Skill Builder offers support for 12 languages such as
Can I use Skill Builder to prepare for AWS certifications?
Yes, certification prep is included in AWS Skill Builder through
How much does AWS Skill Builder cost?
It charges $29 per month or $299 per annum, with
Is AWS Skill Builder free?
AWS Skill Builder offers both free and paid subscription plans.
What is AWS Skill Builder?
AWS Skill Builder is an online website with more than
Can induction training be completed online?
Yes, some companies conduct induction training using e-learning platforms, with
How long does induction training take?
Induction training will typically occur within the initial few days
What does an induction training program involve?
It involves company history, role-specific training, policies, health and safety,
Why is induction training necessary?
It makes new employees feel welcomed, acquire key skills, and
What is induction training?
Induction training is the process of introducing new employees to
Module 6: Automotive Software Testing Techniques
Requirements-based testing, boundary value analysis, equivalence partitioning Error guessing, exploratory
Module 5: Integration Testing and Stub Development
Integration testing strategies (top-down, bottom-up, big-bang) Stub and driver development
Module 4: Unit Testing and Code Coverage
Principles of unit testing & Test-Driven Development (TDD) Code coverage
Module 3: Automotive Software Testing Stages (MIL, SIL, HIL)
Model-in-the-Loop (MIL) Testing: Simulation, verification of control logic Software-in-the-Loop (SIL)
Module 2: Software Testing Life Cycle (STLC)
Detailed explanation of STLC phases Requirements analysis Test planning &
Module 1: Introduction to Software Verification and Validation
Fundamentals of software testing and V&V Importance of testing in
Module 7: Model Automation using M-Scripting
Automating Simulink tasks with M-scripting Generating reports and automating simulations
Module 6: Autocode Generation and Rapid Control Prototyping
Simulink Coder and Embedded Coder for code generation Deploying generated
Module 5: Stateflow Design and Implementation
Introduction to Stateflow and event-driven logic Designing state machines for
Module 4: Control Algorithm Implementation in Simulink
Designing control algorithms using Simulink blocks Implementing PID controllers and
Module 3: Automotive Plant Modeling
Modeling physical systems using Simulink Creating plant models for EV/ADAS
Module 2: Simulink Concepts and Solver Basics
Simulink model structure, hierarchy, and signal types Solver types (fixed-step,
Module 1: Introduction to MBD and MATLAB/Simulink
Model-Based Development (MBD) concepts and benefits Overview of MATLAB/Simulink environment
Module 7: Vehicle Diagnostics, UDS, and OBD
Vehicle diagnostics concepts and standards Unified Diagnostic Services (UDS) and
Module 6: Hardware Security Module (HSM) and Automotive Gateway ECU
HSM concepts: secure boot, secure communication Gateway ECU architecture: network
Module 5: FlexRay
FlexRay protocol fundamentals: time-triggered architecture, frame formats FlexRay controller configuration
Module 4: Automotive Ethernet
Ethernet fundamentals: OSI model, TCP/IP stack, switching & routing Automotive
Module 3: Local Interconnect Network (LIN)
LIN protocol fundamentals: master-slave communication, error detection LIN programming: scheduling,
Module 2: Controller Area Network (CAN)
CAN protocol fundamentals: frame formats, bit timing, error handling CAN
Module 1: Introduction to In-Vehicle Networking
Overview of in-vehicle communication systems and network architectures Introduction to
Module 6: Application of FuSA in EV and ADAS
FuSA in EV Systems: Battery Management Systems (BMS), Electric Drive,
Module 5: Software Development
Software safety requirements & design Unit testing, integration testing, and
Module 4: Functional Safety Concept and Technical Safety Requirements
Development of safety goals and requirements Technical safety concept &
Module 3: Hazard Analysis and Risk Assessment (HARA)
Hazard identification and classification ASIL determination and risk assessment Case
Module 2: ASPICE Process Areas and the SDLC
System & Software Development Lifecycle (SDLC) Requirements Engineering (SYS.1, SWE.1)
Module 1: Introduction to ASPICE and Functional Safety
Overview of ASPICE and its purpose ASPICE process assessment model
Module 5: Advanced C++ Concepts for Embedded Systems
Templates: Generic programming Exception handling: Error management in embedded systems
Module 4: Polymorphism
Concept of polymorphism: One interface, multiple implementations Compile-time polymorphism: Function
Module 3: Inheritance
Concept of inheritance: Code reusability and extensibility Types of inheritance:
Module 2: Classes and Objects
Defining classes: Data members and member functions Creating objects: Instantiation
Module 1: Introduction to Object-Oriented Programming
Procedural vs. Object-Oriented Programming paradigms Core OOP concepts: Encapsulation, Inheritance,
How does edForce enhance LILT?
edForce provides advanced tools and resources that improve communication, engagement,
How can the success of LILT be measured?
Success can be measured through participant engagement levels, knowledge retention
What are some challenges of LILT?
Challenges include scheduling conflicts, technological issues, and participant distractions, which
What are the benefits of LILT?
Benefits include real-time interaction, high engagement levels, a customized learning
What is Live Instructor-Led Training?
Live Instructor-Led Training (LILT) is a real-time teaching approach where
Module 5: Extending Ansible with Custom Plugins
Developing and using custom modules Writing filters and lookup plugins
Module 4: Performance Tuning and Optimization
Efficient inventory management and parallel execution Reducing playbook execution time
Module 3: Event-Driven Automation
Integrating Ansible with external event sources Creating automated response mechanisms
Module 2: Automating at Scale with Automation Controller
Managing automation workflows with job templates Role-based access control and
Module 1: Advanced Playbook Development
Writing reusable playbooks with roles and modules Implementing Jinja2 templating
Module 10: Customizing an OpenStack Data Plane
Apply custom configurations to data plane node sets. Verify the
Module 9: Inspecting Data Plane Services and Compute Nodes
Identify OpenStack data plane resources. Assess the health and performance
Module 8: Verifying Network Encryption for OpenStack Services
Inspect the configuration of OpenStack components. Verify that network communications
Module 7: Verifying Reliable OpenStack Services
Configure high availability for the OpenStack control plane. Assess the
Module 6: Accessing Storage Resources in OpenStack
Verify the status and connectivity of OpenStack storage resources. Ensure
Module 5: Verifying Connectivity to OpenStack Cell Services
Confirm that an OpenStack cell is connected to its database
Module 4: Verifying OpenStack API Connectivity
Identify resources connecting the OpenStack control plane to its data
Module 3: Customizing OpenStack Services
Enable and disable specific OpenStack services as needed. Apply custom
Module 2: Inspecting OpenStack Services on OpenShift
Identify OpenStack services deployed on OpenShift. Assess the health of
Module 1: Introduction to Red Hat OpenShift Container Platform
Understand the architecture and resources of Red Hat OpenShift. Navigate
Module 7: Troubleshooting OpenShift Data Foundation
Identifying and resolving common issues. Understanding Ceph storage components and
Module 6: Managing Storage Capacity with OpenShift Data Foundation
Expanding storage capacity as needed. Implementing storage quotas and limits.
Module 5: Backing Up and Restoring Kubernetes Block and File Volumes
Implementing backup strategies using Kubernetes CSI APIs. Restoring application data
Module 4: Configuring OpenShift Cluster Services to Use OpenShift Data Foundation
Setting up OpenShift Monitoring to utilize OpenShift Data Foundation storage.
Module 3: Configuring Application Workloads to Use OpenShift Data Foundation Object Storage
Setting up object storage buckets. Integrating applications with object storage
Module 2: Configuring Application Workloads to Use OpenShift Data Foundation File and Block Storage
Selecting appropriate storage classes for applications. Configuring Persistent Volume Claims
Module 1: Architecture Overview and Deployment of OpenShift Data Foundation using Internal Mode
Understanding OpenShift Data Foundation features and deployment architectures. Installing OpenShift
Module 13: Comprehensive Review
Applying learned skills by observing system performance, evaluating metrics, and
Module 12: Tuning in Virtualized Environments
Understanding the requirements and techniques for tuning in virtualized settings.
Module 11: Network Optimization
Improving application efficiency in network utilization.
Module 10: File System Optimization
Enhancing application efficiency concerning file system utilization.
Module 9: Storage I/O Optimization
Managing settings for efficient disk utilization across various use cases.
Module 8: Memory Optimization
Configuring settings for efficient memory utilization tailored to different workloads.
Module 7: CPU Optimization
Managing CPU resource sharing and scheduling to control utilization.
Module 6: System Tracing Tools
Diagnosing system and application behaviors using various resource-specific tracing tools.
Module 5: Resource Management with Control Groups
Managing resource contention and setting limits for services, applications, and
Module 4: Kernel Tunables and ‘tuned’ Profiles
Configuring the operating system to optimize for different workload requirements.
Module 3: Hardware Resource Analysis
Viewing and interpreting hardware resource listings.
Module 2: Performance Monitoring Tools
Evaluating a variety of performance monitoring tools included with Red
Module 1: Introduction to Performance Tuning
Understanding performance tuning concepts and goals.
Module 7: Troubleshooting High Availability Clusters
Diagnosing and resolving common cluster issues Using cluster logs and
Module 6: Configuring GFS2 File Systems
Creating GFS2 file systems Mounting and managing GFS2
Module 5: Implementing Cluster-Aware LVM
Creating shared LVM volumes Managing cluster-aware LVM configurations
Module 4: Working with Shared Storage
Configuring iSCSI initiators Setting up multipath I/O
Module 3: Managing Cluster Services
Creating and managing cluster resources Configuring resource constraints
Module 2: Configuring High Availability Clusters
Installing and configuring Pacemaker Setting up cluster quorum and fencing
Module 1: Introduction to High Availability Clustering
Understanding high availability concepts Overview of the Red Hat High-Availability
Module 5: Post-Installation Cluster Configuration
Finalizing cluster services Storage setup Networking configurations Validating cluster health
Module 4: Troubleshooting Installation Issues
Common installation pitfalls Network issues Resource constraints Collecting and analyzing
Module 3: Monitoring the Installation Process
Stages of the OpenShift installation Bootstrap process Control plane establishment
Module 2: Executing the OpenShift Installer
Running the installer with custom settings Configuration parameters Deployment targets:
Module 1: Preparing for OpenShift Installation
Assessing infrastructure prerequisites Hardware and software requirements Network configurations Planning
Module 5: Integrating Ansible with IT Ecosystems
Connecting Ansible with CI/CD pipelines for automated deployments. Integrating Ansible
Module 4: Scaling Ansible in Enterprise Environments
Designing Ansible architectures for large-scale deployments. Implementing Ansible Tower/AWX for
Module 3: Ansible Performance Optimization
Profiling and tuning Ansible playbooks for optimal performance. Implementing strategies
Module 2: Custom Module Development
Understanding the architecture of Ansible modules. Developing custom modules to
Module 1: Advanced Playbook Techniques
Implementing loops and conditionals for dynamic task execution. Utilizing blocks,
Module 6: Enhancing Security with Advanced Cluster Security (ACS)
Deploying ACS in the hub cluster. Integrating ACS with ACM
Module 5: Implementing Quay for Image Management
Installing and configuring Quay. Integrating Quay with OpenShift and ACM.
Module 4: Application Management Across Clusters
Establishing application placement rules. Deploying applications using GitOps. Monitoring application
Module 3: Policy-Driven Cluster Management
Defining cluster configuration policies. Applying and monitoring policies. Automating compliance
Module 2: Deploying Advanced Cluster Management (ACM)
Setting up ACM in a hub cluster. Configuring managed clusters.
Module 1: Introduction to Multicluster Management
Understanding multicluster architectures. Challenges in managing multiple clusters. Overview of
Module 11: Comprehensive Review
Reinforcing key concepts and skills covered throughout the course.
Module 10: Automating Common Windows Administration Tasks
Automating routine Windows Server administrative tasks.
Module 9: User and Domain Management
Managing local and domain users. Administering Active Directory domains. Generating
Module 8: Reusing Code with Roles and Collections
Organizing Playbooks for larger projects. Incorporating existing automation code through
Module 7: File Deployment and Management
Deploying, modifying, and managing files on Windows servers. Using Jinja2
Module 6: Task Control and Error Handling
Implementing loops, conditional tests, and handlers in Playbooks. Designing Playbooks
Module 5: Software Installation and Management
Automating the installation and updating of software on Windows servers.
Module 4: Managing Variables and Facts
Utilizing variables to simplify Playbook management. Gathering and using facts
Module 3: Writing and Executing Ansible Playbooks
Crafting Playbooks to automate tasks on multiple Windows hosts. Running
Module 2: Preparing Windows Hosts for Ansible
Setting up Windows servers for Ansible automation. Configuring the automation
Module 1: Introduction to Ansible Automation Platform
Fundamental concepts of Ansible. Installation of development tools from Ansible
Module 7: Integrating VMs with External Services
Connecting VMs to external data center services like storage and
Module 6: High Availability and Resource Management
Implementing high availability for VMs using Kubernetes features. Controlling CPU,
Module 5: Advanced VM Management
Cloning and snapshotting VMs. Creating and utilizing golden VM images.
Module 4: Storage Provisioning for VMs
Provisioning storage using Persistent Volume Claims (PVCs) and Persistent Volumes
Module 3: Networking for Virtual Machines
Connecting VMs using Kubernetes services, ingress, and routes. Integrating VMs
Module 2: Creating and Managing Virtual Machines
Creating VMs from installation media. Accessing VM consoles (text and
Module 1: Introduction to OpenShift Virtualization
Overview of OpenShift Virtualization. Benefits of integrating VMs into OpenShift.
Module 10: Integrating Ceph Storage with OpenStack
Integrate Ceph Storage with OpenStack services like Glance and Cinder
Module 9: Managing a Ceph Storage Cluster
Perform day-to-day operations and maintenance tasks on a Ceph Storage
Module 8: Providing File Storage Using CephFS
Configure Ceph Storage to provide file storage for clients using
Module 7: Providing Object Storage Using a RADOS Gateway
Configure Ceph Storage to provide object storage for clients using
Module 6: Providing Block Storage Using RADOS Block Devices
Configure Ceph Storage to provide block storage for clients using
Module 5: Creating and Customizing Storage Maps
Manage and adjust the CRUSH and OSD maps to optimize
Module 4: Creating Object Storage Cluster Components
Create and manage components that comprise the object storage cluster,
Module 3: Configuring a Ceph Storage Cluster
Manage the Ceph Storage configuration, including primary settings, the use
Module 2: Deploying Ceph Storage
Deploy a new Ceph Storage cluster and expand the cluster
Module 1: Introducing Ceph Storage Architecture
Describe Ceph Storage architecture, including data organization, distribution, and client
Module 12: Comprehensive Review
Consolidate and review the skills and knowledge acquired throughout the
Module 11: Automating Compliance with Red Hat Satellite
Scale and automate compliance checks with Red Hat Satellite.
Module 10: Analyzing and Remediating Issues with Red Hat Insights
Identify and address common security vulnerabilities using Red Hat Insights.
Module 9: Managing Compliance with OpenSCAP
Assess and remediate system compliance using OpenSCAP.
Module 8: Mitigating Risk with SELinux
Apply SELinux policies to improve security and process confinement.
Module 7: Monitoring File System Changes
Deploy AIDE to detect and analyze changes in file systems.
Module 6: Recording System Events with Audit
Utilize the Linux kernel's Audit system to record and inspect
Module 5: Controlling Authentication with PAM
Configure PAM to manage authentication and authorization settings.
