Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Learning DevOps Tools Complete Course Step-by-Step(2025)
Role Play
Rating: 4.3 out of 5(44 ratings)
467 students

Learning DevOps Tools Complete Course Step-by-Step(2025)

A hands-on starter pack: version control with Git, automation with Ansible, Python and Bash scripts, labs with Vagrant
Created byVitalii Shumylo
Last updated 11/2026
English
English [Auto],Japanese [Auto],

What you'll learn

  • Track your work with Git: commits, branches, remote repositories and gitignore
  • Automate servers with Ansible: inventories, ad hoc commands, playbooks, variables, secrets, facts, loops and handlers
  • Build single and multi-machine labs with Vagrant
  • Learn Python from the first variable to functions, files and small scripts, and try a Flask project
  • Get a first look at NGINX with a LEMP stack, Kubernetes pods and probes, and Azure virtual machines and networking
  • Practise the Linux command line in an hour-long set of lectures
  • Read and write YAML, and set up Vim and VS Code for it

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

See a demo
Image of coding exercise example

Course content

1 section • 190 lectures • 17h 19m total length
  • Introduction to Git1:54

    Learn how git enables distributed version control, with offline work and trackable history. Compare git with GitHub, a service that helps manage git controlled projects.

  • Getting installed1:23

    Install git across Windows, macOS, and Ubuntu, use git bash to run commands, install via Homebrew or apt, verify with git --version, and set global configuration.

  • A few important configuration settings2:47

    Configure global git settings by setting your name and email, enable color output, and edit .gitconfig for all repos; then create your first git project and run commands.

  • Creating a project. The first commit6:06

    Create a project directory and initialize a Git repository. Add files, check status, stage changes, and make a meaningful commit; learn to push to a remote repository for collaboration.

  • Working with remote repositories3:36

    Move your local repository to a remote repository to enable access from anywhere and collaboration. Create a GitHub repo, add origin with the remote URL, verify, and push your project.

  • Cloning a project from the remote repository2:26

    clone a remote repository using git clone, then push local changes with git add, commit, and push to origin master, and finally pull updates with git pull.

  • Configuring .gitignore file3:46

    Configure a .gitignore file to hide files from git tracking and status, then add items and commit them, noting you may accidentally add a listed file and see no error.

  • Git important commands. Viewing commits' history4:11

    Explore viewing commit history with git log and git show, while staging changes with git add, committing, and using git diff to review modifications and diff outputs.

  • Branches in Git. Creating, deleting and renaming branches5:36

    Explore git branching fundamentals by creating, renaming, and deleting branches, switching between master and other branches, and safely managing work with local and remote branches.

  • Section Quiz: Git
  • Course Introduction1:38

    Install answerable, build a demonstration lab, and practice with ad hoc commands, a playbook, and an inventory file to master configuration management and infrastructure orchestration.

  • Getting Installed3:25

    Discover installation options for the tool across macOS, Windows, and Linux using Python, pip, homebrew, and vagrant, and build a multi-VM lab with a master node and client nodes.

  • Configuring the Environment4:34

    Configure the environment on the master node by installing the official package, updating repositories, and validating the installed version; then set up hosts and ssh keys for node access.

  • Ad Hoc Commands and an Inventory File4:54

    Learn to run ad hoc commands across remote servers using an inventory file, organize hosts into groups, and reference the hosts file to target specific servers with simple commands.

  • Ad Hoc Commands3:06

    Use ad hoc commands with inventory groups to check hostnames, disk space (df -h) and memory (free -m), then explore Ansible modules like apt for present, absent, and update_cache.

  • Playbooks. Part 12:31

    Create and run playbooks that automate multiple tasks using plays and modules, and learn yaml playbook structure, hosts configuration, and executing with the playbook command.

  • Playbooks. Part 27:36

    Learn how playbooks orchestrate tasks across multiple servers using modules, variables, and hosts, including creating files and directories, installing packages, and starting services, and using become for privileges.

  • Playbooks. Part 32:46

    Create multiple directories with the file module via a with_items loop, and use the user module to create or remove users by specifying username, password, groups, shell, and state=absent.

  • Playbooks. Part 47:09

    Master playbook workflows with loops, file creation, content copying, and archival tasks. Manage Debian-like and Red Hat systems with apt and yum, performing updates, installs, and zip files across groups.

  • Course Introduction4:06

    Learn to manage virtual development environments with vagrant using a simple vagrantfile, deployable via providers like virtualbox, aws, or hyper-v, and provisioning with puppet or chef.

  • Getting installed4:15

    Install Weygand on Linux, Windows, or macOS using VirtualBox and Vagrant, verify installations with version checks, and prepare virtual machines for DevOps workflows.

  • Working with s single VM. Section Overview0:58

    Learn to manage vagrant boxes and a single vm by initializing base boxes, controlling power, suspend, resume, and connecting, with port forwarding, folder mapping, and networking.

  • Importing and using base boxes8:51

    Learn how to import and use base boxes with vagrant, initialize a project, configure a Vagrantfile, specify box names and download sources, and bootstrap virtual machines.

  • Managing Vagrant boxes. Part 13:38

    Manage vagrant boxes with list, remove, and up, install base boxes, configure a provider, forward port 22, enable networking, map shared folders, and run provisioning.

  • Managing Vagrant boxes. Part 29:41

    Learn how to manage vagrant boxes, destroy and recreate environments, connect via SSH, and configure port forwarding, synced folders, networking, and shell provisioning to automate VM setup.

  • Managing Vagrant boxes. Part 34:36

    Learn to manage vagrant boxes with commands to add, list, check updates, update, remove, and monitor multiple projects using status and global-status, then reload or destroy boxes as needed.

  • Working with multiple VMs. Section Overview1:25

    Learn to run multiple virtual machines in a single Vagrant project, configure distinct names, IPs, boxes, provisioning, and shared folders, and connect to each VM without remembering IPs.

  • Defining and connecting to multiple virtual machines4:41

    Define and map multiple virtual machines in a vagrant project by configuring each virtual machine, naming them, and mapping host ports to enable ssh access and multi-machine connections.

  • Networking the multiple virtual machines3:46

    Configure two virtual machines to communicate over a private network, using non-conflicting IPs in 192.168.1.x and port forwarding as needed, then verify connectivity between server one and server two.

  • Section Quiz: Vagrant
  • Building Ansible Lab Environment9:37

    Set up a ready-made Ansible lab environment using Vagrant and multiple virtual machines. Learn to install Ansible on the control node, prepare managed hosts, and configure SSH key-based access.

  • Describing Ansible Inventory Files10:03

    Describe how Ansible inventory files organize hosts into static or dynamic inventories, using host groups and child groups, with variables and ranges, and how to verify and configure inventories.

  • Guided Exercise: Ansible Inventory Files6:19

    Practice creating and managing static Ansible inventories by defining hosts and groups in the default and a custom inventory. Assign hosts to multiple groups and validate with inventory commands.

  • Managing Ansible Configuaration Files10:54

    Describe and edit Ansible configuration files, locate and select the proper configuration file, use the ANSIBLE_CONFIG environment variable to override, and manage defaults, inventory, and connection settings across environments.

  • Managing Connectivity and Configuaration Files10:29

    Explore configuring connectivity and deployment of public keys across managed hosts using Ansible. Learn about authorized_key deployments, privilege escalation with become, and managing local and remote connection types.

  • Guided Exercise: Managing Ansible Configuaration Files5:14

    Practice configuring Ansible environment by creating a default and static inventory with host groups, then test with list hosts and enable privilege escalation to root.

  • Running Ad Hoc Commands15:14

    Execute a single Ansible task quickly with ad hoc commands, without writing a playbook. Learn about modules, hosts, and basic arguments for quick operations.

  • Guided Exercise: Running Ad Hoc Commands7:58

    Execute ad hoc commands across multiple managed hosts with privilege escalation using Ansible. Learn to verify sudo configuration, configure inventory, and perform file edits on both control node and server.

  • Lab: Deploying Ansible11:47

    Configure an Ansible control node, set up inventory and defaults, and use ad hoc commands with the DevOps user and copy module to manage hosts.

  • Implementing Playbooks13:58

    Implement playbooks by writing a simple Ansible playbook and running it to automate tasks across multiple hosts, using YAML plays, hosts, and tasks.

  • Guided Exercise: Implementing Playbooks8:02

    Write and run an Ansible playbook in YAML to install httpd, copy index.html to /var/www, and start and enable the httpd service on the web host group; verify syntax.

  • Multiple Plays15:46

    Learn to write a YAML playbook with multiple plays for different hosts, manage privilege escalation, explore modules, and use the Ansible documentation.

  • Guided Exercise: Multiple Plays9:39

    Create a multi-play Ansible playbook to manage a local host, enable privilege escalation, update packages, copy intranet content, verify with local tests and a syntax check.

  • Lab: Implementing Playbooks8:40

    Configure and run an Ansible playbook to install, configure, and verify web and database services on a managed host, with firewalld setup, privilege escalation, and control-node testing.

  • Managing Variables13:41

    Define and use variables and facts in Ansible playbooks, manage scope from inventory to playbook, and leverage register and extra vars for dynamic host configurations.

  • Guided Exercise: Managing Variables6:17

    Define and use variables in an Ansible playbook to install the latest Apache web server, configure firewall, start services, and verify the web server with status code 200 checks.

  • Managing Secrets13:34

    Encrypt and decrypt sensitive data with Ansible Vault to protect inventory variables, playbooks, and variable files. Use AES-256, vault passwords, and password files to manage secrets.

  • Guided Exercise: Managing Secrets4:39

    Manage secrets with Ansible by decrypting an encrypted secret YAML file and running a playbook that creates an Ansible user on a remote host.

  • Managing Facts14:54

    Discover how Ansible gathers and uses facts to reference host data, configure custom facts, and leverage magic wearables for dynamic playbooks.

  • Guided Exercise: Managing Facts4:57

    Master gathering host facts with the Ansible setup and custom facts workflow, create and verify playbooks, install packages, and enable and start services on remote web servers.

  • Lab: Managing Variables and Facts8:30

    Automate a web server environment with an Ansible playbook, configuring inventory, secrets, and authentication, installing firewall and web packages, then validating content via basic authentication.

  • Lab: Managing Variables and Facts11:14

    Configure an Ansible playbook to install packages, set up basic authentication, manage firewall rules, and deploy secret files for secure web access; validate with tests and debug outputs.

  • Writing Loops and Conditional Tasks17:08

    Explore writing loops and conditional tasks in Ansible playbooks, using the loop keyword to iterate over lists or dictionaries, and applying conditionals with when to control task execution.

  • Guided Exercise: Writing Loops and Conditional Tasks3:08

    Practice guided exercise on writing loops and conditionals with Ansible, creating a playbook to install MariaDB packages and start the service, using inventory and host groups for Red Hat systems.

  • Implementing Handlers8:50

    explains how ansible handlers respond to task changes, use notify to trigger restarts or service reloads, and ensures handlers run once after relevant tasks complete for database configuration playbooks.

  • Handling Task Failure6:35

    Learn how to manage task failures in Ansible, including ignore errors, force handlers, failed conditions, and rescue and always blocks to control execution and recovery.

  • Guided Exercise: Handling Task Failure8:22

    Explore methods to handle task failure in an Ansible playbook by using ignore failed commands during execution, block rescue and always sections to control failure and ensure recovery.

  • Guided Lab:Implementing Task Control5:31

    participate in a lab on implementing task control with Ansible: define conditionals and loops, manage handlers and services, configure SSL and firewall, and verify a web server with self-signed certificate.

  • Install NGINX on Ubuntu3:01

    Install nginx on Ubuntu by provisioning a Vagrant Linux VM, updating and upgrading packages, then installing nginx and verifying with systemctl and a browser request to 192.168.0.3.

  • NGINX files and directories and CLI7:06

    Explore /etc/nginx, including sites-available and sites-enabled, and the /var/log/nginx and /var/www/html directories, and manage the service with systemctl commands and nginx -t and -T tests.

  • nginx.conf and vhost config9:20

    Explore nginx.conf and vhost setup by editing the main config, using simple and block directives, and creating a Wisdom Pet Medicine vhost; test, reload, and verify locally.

  • Add files to the root directory and configure locations8:58

    Add files to the root directory and configure locations in engine x using Vagrant, unzip assets, set secure permissions, and test custom 404 and 500 pages.

  • Configure logs and troubleshoot NGINX6:18

    Configure Nginx logs with access_log and error_log for a virtual host, then test and reload the config while using curl, netstat, and tail to troubleshoot http/https ports and events.

  • Install PHP on NGINX5:28

    Install PHP on nginx by installing php-fpm and php-mysql, then configure nginx to pass PHP requests to php-fpm via fastcgi and verify with a PHP info page for development.

  • Install MariaDB on NGINX and LEMP stack demonstration10:21

    install MariaDB on the LEMP stack with NGINX, secure the installation, create an appointments database and an admin user, and run a PHP app that lists appointments through MySQL.

  • Section Quiz: Nginx
  • Using Initial Commands7:39

    Verify your cluster is running with the Gloster command, inspect ports and deployments, and understand the virtual IP network. Forward traffic to a cluster port for external access.

  • Creating Your First Pod5:25

    Create your first pod by understanding the kubernetes object structure—metadata, spec, and status—set a default namespace, use labels and selectors, and craft a YAML configuration.

  • Creating Your First Pod. Part 27:37

    Create a single-container port using a YAML file, learn YAML structure and indentation, deploy with vagrant, and verify port details and namespace settings.

  • Working with Namespaces5:57

    Learn to work with namespaces, view all available namespaces, switch the default context to a chosen namespace, and create and verify a port in that namespace using a YAML configuration.

  • Working with containers inside a pod11:29

    Create and configure a pod with one or more containers by defining a yaml file, including image, command, ports, environment variables, and resource limits; verify with CubeSat describe and logs.

  • Using Probes8:27

    Explain port lifecycle states and implement liveness and readiness probes to monitor container health, configure initial delays, timeouts, and restart policies for reliable port operation.

  • Errors During Every Release: Adding Probes to the Deployment
  • Section Quiz: Kubernetes
  • Introduction3:28

    Explore the Asia portal, a multi-tenant cloud platform for deploying and managing Asia resources. Learn portal navigation, accounts, marketplace, blades, and the Asia Resource Manager.

  • Azure Portal and Navigation5:51

    Explore Azure portal navigation, sign in and customize the dashboard with tiles like all resources, marketplace, and service health; manage favorites, activity log, and help resources.

  • Azure Virtual Machines and Compute Basics. Intro1:41

    Learn Azure virtual machines and infrastructure as a service by deploying a 2016 vm, configuring backup, and building a virtual network with availability sets and dynamic and static ip addresses.

  • Building Virtual Network3:30

    Create a virtual network in the Asia portal, configure its IP address blocks, DNS settings, and security policies, then add a subnet with a /26 range and deploy.

  • Creating an Azure Availability Set3:16

    Create an Azure availability set, distribute virtual machines across fault and update domains for resilience, and enable managed disks to simplify storage management during deployment.

  • Deploying a Virtual Machine8:06

    Deploy a virtual machine by selecting subscription, resource group, region, and availability set, then choose Windows Server 2016 data center, size, networking, and monitoring.

  • Backup and Recovery2:17

    Learn to configure a separate user-accessible backup for a virtual machine protected by locally redundant storage, using recovery services vault, set a daily policy, and verify deployment status.

  • Azure Networking Concepts9:11

    Explore Asia virtual network capabilities, including isolation and segmentation, private IP address spaces, subnets, and DNS, plus secure internet, VPN connectivity to on-premises, routing, and peering.

  • Building a Virtual Network4:02

    Create a virtual network in the Asia subscription, extend the address space from /24 to /16, and add a production subnet with /24 while configuring routing and security policies.

  • Building network security groups4:36

    Configure a network security group to block or allow traffic using ACLs. Add inbound rule for web traffic on port 80 and associate the group with a virtual network subnet.

  • Building a network load balancer3:16

    Create a load balancer that distributes traffic across healthy virtual machine instances using a hash-based distribution algorithm that uses source IP, source port, destination IP, destination port, and protocol type.

  • Creating a Virtual Network Gateway4:46

    Create a virtual network gateway to encrypt traffic between a virtual network and on premises over a public connection, including road-based, site-to-site, and point-to-site options.

  • Getting Installed3:25

    Install and configure Python 3 via Anaconda, including setting up Jupyter notebooks, adding to PATH on Windows, and launching a new Python 3 notebook to begin coding.

  • Adding Comments. Data Types3:59

    Learn how python uses comments, code cells, and multiline strings to document code, while mastering data types—integers, floats, booleans, and strings—and the print statement.

  • Data Types cont.3:29

    Learn the core data types in programming: integers, floats, booleans, and streams (strings), with practical examples on printing and usage in calculations.

  • Adding Variables3:15

    Learn how variables store data in memory with descriptive names, declare values, and access them later. Understand naming rules, case sensitivity, and simple integer and float examples.

  • Variables cont.4:02

    Master boolean variables and data types in Python by storing true and false, distinguishing strings from integers, and using operators to manipulate variables in simple calculations.

  • Working with Strings3:53

    Learn to work with strings in Python, concatenate strings to build text, store names in variables, and format output with the format method and f-strings for readability.

  • Strings cont.3:53

    Learn to work with strings by concatenating and formatting in Python, using the format method and f-strings to inject variables and build readable text.

  • Strings cont.3:37

    Learn to manipulate strings using methods like title, lower, upper, replace, find, strip, and split. Use these tools to format names, locate word positions, and tokenize input.

  • Working with User Input. Type Converting3:16

    Learn how to convert user input to integers and handle errors with try and except, ensuring programs don’t crash when nonnumeric input occurs; understand Python indentation rules and code blocks.

  • Type Converting cont.3:44

    Learn to use if statements to decide which code blocks run based on conditions and comparison operators, with true/false outcomes and user input conversion to integers.

  • Logical Operators4:19

    Explore logical operators and, or, not, plus membership operators in checks within if statements, showing how multiple conditions determine if code runs in devops tools.

  • ELIF Statement5:09

    Master elif statements in python by learning how they extend if statements with multiple conditions, top-to-bottom evaluation, and indentation, ensuring only the first true block runs.

  • ESLE Statement2:41

    Explore how the else statement in Python handles all remaining possibilities when if and elif conditions fail, with examples using else, elif, and indexing a string.

  • Strings2:42

    Define strings as sequences of characters and data types. Learn to enclose them with single or double quotes in Python, and verify proper matching in print statements.

  • Int, Variables and Data Types4:21

    Explore integers, variables, and data types, including how integers are whole numbers, how strings hold characters (digits as text, not numbers), and how wearables name and reuse values.

  • Type() Function2:36

    Identify and distinguish data types by using the type function to classify integers, floats, and strings, and practice with echoing results and type checks.

  • Addition: Numbers and Strings2:08

    Explore the addition operator for arithmetic with integers and floats, and for string concatenation within brain function and screen output, with practical practice tasks.

  • Addition: Variables3:35

    Explore the addition operator with wearables to initialize and update variables, perform integer and string concatenation, build greetings by combining names and literals, and reuse code.

  • Errors are Your Friend. Handling Errors.6:55

    Learn how to troubleshoot common Python errors, including type errors from mixing strings and numbers, syntax errors from mismatched quotes, and name errors from undefined variables.

  • User Input and Input Prompts5:35

    Learn to use the input statement and input prompts to collect user input, assign it to variables or wearables, and understand that input returns a string stream regardless of entry.

  • Comma separated string printing and printing numbers with strings using comma4:57

    Master comma-separated printing to combine strings and numbers in one statement, avoiding type errors and speeding display of information by printing literals, variables, and wearables or screens.

  • Quotes in Quotes and Boolean Strings Tests5:50

    Learn how to display single and double quotes inside strings and validate strings with boolean methods like isalpha, islower, isupper, isnumeric, and startswith in Python-like examples.

  • String Format Methods3:00

    Master string format methods to transform strings with lower, upper, title, and capitalized operations, and explore swap case to flip letter casing in your code.

  • Input. String Formating3:05

    Format user input by applying lower and upper case operations, use input streams to alter wearable color values, and print formatted results for consistent display.

  • Boolean 'in' keyword3:10

    Explore how the 'in' keyword enables searching through strings, demonstrate case sensitivity, and show using dot lower to make both sides lowercase for reliable matches like pizza in a menu.

  • Intro to Lists11:35

    Explore Python lists, a mutable, ordered data collection. Learn indexing, accessing, nested lists, and copying to manage multi-type elements and memory references.

  • For Loops7:55

    Explore how for loops run code multiple times in Python, using range and start, end, and step values, iterating over sequences including strings, with break, continue, and pass for control.

  • While Loops3:45

    Learn how while loops execute based on a condition rather than a count, including how to avoid infinite loops, use break or conditions to exit, and how nested loops behave.

  • Working with Lists9:55

    Learn to work with lists in Python, using len, indexing, slicing, append, insert, pop, remove, and sort or sorted, while exploring duplicates and list conditionals.

  • List Workout: Remove Duplicates, Remove Every Copy, Collect Until Quit
  • Create the simpliest function5:05

    Define simple python functions with def, and explore print with zero to many arguments and its output. Compare time and print behavior, store results, and ensure indentation.

  • Creating a function to iterate through lists1:44

    Build a city search function that iterates through city lists using a default four-city set and an optional longer list, returning true for string matches with the equality operator.

  • Section Quiz: Python for Beginners
  • Getting Installed1:03

    Install Python by visiting python.org, downloading for your OS, and running the installer; customize the installation, set a target directory like C:\Python\Python3.8, and verify with Python in the command line.

  • OS module: files, paths, etc7:14

    Explore how file names, paths, and extensions define file location across windows and linux, and learn to use os.path.join, absolute and relative paths, current working directory, and directory creation.

  • Handling Absolute and Relative Paths. Checking Path Validity11:23

    Learn how to work with absolute and relative paths using the Python os.path module, convert paths, build joins, and check path validity and existence.

  • Working with Files: Read, Write, Append Methods7:05

    Learn to read, write, and append plain text files in Python using open and a file object. Practice read lines and write modes, and use os.remove to delete files.

  • Working with Files: shutil7:05

    Explore how to use the shutil module to copy files with copy and copytree, rename and move items, and manage backups in Python.

  • Types and Variables4:42

    Learn strings, quotes, and integers; see how Python uses variables like current_message and item_price to store, reassign values, and change data types, with # comments and friendly names.

  • Hands-On Examples: Using Comments in Code1:23

    Explore practical Python code examples that use single and multi-line comments to annotate arithmetic operations, demonstrating addition with variables, a list sum via the built-in sum function, and printed results.

  • Hands-On Examples: Data Types in Python2:44

    Explore hands-on Python data types—integers, floats, strings, booleans, lists, tuples, and dictionaries—through practical examples of operations and printing results.

  • Hands-On Examples: Variables in Python2:27

    Explore hands-on Python variable operations, including assigning, reassigning, multi-variable assignment, swapping, and string concatenation with print outputs through practical examples.

  • Hands-On Examples: Adding Variables in Python3:15

    Explore how to add variables of different data types in Python, including integers, floats, strings, lists, tuples, and dictionaries, using the plus operator and str conversion for concatenation.

  • Hands-On Examples: Working with Strings. Example 12:26

    Explore how to assign and concatenate strings in Python, format with placeholders, and access or slice characters. Learn to measure length, replace substrings, convert case, and split strings into lists.

  • Hands-On Examples: Working with Strings. Example 21:49

    Explore Python string operations, including joining lists into sentences and stripping whitespace. Check starts with, ends with, and contains with the in operator.

  • Hands-On Examples: Working with Strings. Example 32:11

    Explore practical Python string operations, including encoding to bytes, decoding, formatting with leading zeros, padding, removing characters and digits with translate, and using templates with format.

  • Hands-On Examples: Working with Strings. Example 42:21

    Learn Python string operations through hands-on examples, including capitalizing the first letter, finding substring indices, counting occurrences, converting values with ord and chr, and validating title, upper, and lower cases.

  • Hands-On Examples: Working with User's Inpu. Example 11:39

    Demonstrate Python input handling with prompts, casting to int and float, yes/no decision prompts, and addition; store inputs in a list with for and append; validate with a while loop.

  • Hands-On Examples: Working with User's Inpu. Example 21:28

    Explore Python input handling with practical examples: multiple inputs with split, function calls, list storage, alphabetic validation, and writing text to a file.

  • Hands-On Examples: Working with User's Input. Example 31:32

    Explore practical Python input handling with hands-on examples: build a multiple-choice selector, collect dictionary key-value pairs with a while loop, validate yes/no responses, and verify emails using a regex.

  • Hands-On Examples: Working with Type Convering. Example 11:45

    Explore Python type conversion through hands-on examples, including string to int, float, and bool. Convert among int, float, string, list, tuple, and set as shown.

  • Hands-On Examples: Working with Type Convering. Example 21:35

    Explore practical Python type conversion with hands-on examples: string to list, list to string, dict from items, dict from tuples, from keys, and split or join lines.

  • Hands-On Examples: Working with IF Statements. Example 11:48

    Explore hands-on Python if statements through multiple examples, including simple if, elif and else branches, nested conditions, and one-liners, illustrating condition-driven code execution.

  • Hands-On Examples: Working with IF Statements. Example 21:42

    Explore hands-on Python if statements through examples using logical operators, not, in, is, and try-except, including function calls and absolute value checks to control program flow.

  • Hands-On Examples: Working with Logical Operators. Example 11:54

    Explore Python logical operators through hands-on examples, combining multiple conditions with and, or, not, and parentheses to control precedence in if statements.

  • Hands-On Examples: Working with Logical Operators. Example 21:47

    Explore how Python uses logical operators to filter data and build structures in real code, with examples of and, or, and not in if statements, list comprehensions, and set comprehensions.

  • Hands-On Examples: Working with ELIF. Example 11:36

    Explore python if-elif-else logic through hands-on examples, including value checks, a sine-based function, and loop-based conditions, highlighting readability and maintainability of multi-case code.

  • A Script to Create a Flask Project Using Existing Files4:52

    This script creates a flask_blog project directory and copies static, templates, and blog.py into it using os and shuttle. It checks for existing items and prints notices if missing.

  • A Script to Format Text in Academic Style3:36

    prerequisites: pip install python-docx

  • Creating a New Project: 'microblog'2:25

    Create a new PyCharm project called Micro.blog, set up a virtual environment, and add a Python script that prints a welcome message, then run it to see the output.

  • Installing Python packages in a virtual environment1:42

    Install Python packages in a virtual environment using pip. Keep a separate pip instance, verify with pip freeze, and import in a Python interpreter without affecting the global Python installation.

  • App Structure0:06
  • Using Blueprints6:12

    Discover how Flask blueprints modularize apps into reusable components, defining routes and views, and using register_blueprint to manage authentication functionality.

  • Adding 'blog' Blueprint7:45

    Add a blog blueprint to a Flask app by creating a blog directory with __init__ and views, then register it with the app under /blog alongside the existing auth blueprint.

  • Creating a basic app with debugger6:37

    Create a basic flask web app with a Python script that builds the file structure, including routes / and /about returning html, with static and templates directories and base.html.

  • Using Templates3:35

    Create two new templates home.html and about.html in Flask using Jinja2, render with render_template, and use base.html blocks and inheritance for dynamic home and about pages.

  • Using Templates, CSS and Bootstrap4:52

    Learn how to scaffold a Flask web application by creating a project directory and copying static files, templates, and blog.py using os and shuttle modules.

  • TextApp Project: Project Folder and Requirements3:53

    Set up a Flask-based text management app with SQLite and Bootstrap. Define project structure, app.py, Flask-SQLAlchemy models, routes, and Jinja2 templates, and manage dependencies with a virtual environment and requirements.txt.

  • TextApp Project: 'app.py'. Part 13:10

    Create and configure a Flask app with an SQLite database and SQL Alchemy. Initialize the core app file, including routing and database models, and disable track modifications to boost performance.

  • TextApp Project: 'app.py'. Part 22:26

    Define a text model that inherits from the DB model to map the texts table in a Flask SQLAlchemy app, with id, name, and content columns.

  • TextApp Project: 'app.py'. Part 33:24

    Define a root home page that renders the Home.html template. Add a slash add_text route with get and post to create, save to database, and redirect to the text page.

  • TextApp Project: 'app.py'. Part 15:03

    Develop a Flask text app with routes to list all texts and display a specific text by id, using get_or_404 and render_template with Jinja2 templates.

  • TextApp Project: 'templates/base.html'4:02

    Create and organize the templates folder in a Flask app to render dynamic html, separating logic from presentation, and implement base.html with Bootstrap and url_for driven navigation for child templates.

  • TextApp Project: 'templates/home.html', 'templates/add_text.html'5:20

    Review the jinja2 home.html and add_text.html templates for the text app, showing how base.html is extended, blocks are overridden, and how Flask, SQLite, and Bootstrap render the pages.

  • TextApp Project: templates/add_text.html, templates/texts_page.html5:24

    Learn how the TextApp uses Jinja2 templates to render individual text pages and the texts list by extending base.html, displaying the text name and content, with links to each text.

  • TextApp Project: file ('app.py') and templates interconnection4:12

    Discover how to connect app.py with templates in a Flask app using jinja2 and render_template. Learn how template inheritance with base.html enables dynamic pages.

  • Testing the TextApp Functionality5:37

    Create a static folder with css and js subfolders, add main.css styling for body, container, headings, and form elements; implement a DOMContentLoaded main.js listener and run python App.py.

  • Listing Directories. Part 13:41

    Master listing directories with ls, including the home directory and hidden dot files via ls -a and details via ls -l, and consult manual pages with man.

  • Listing Directories. Part 22:29

    Learn to read a long directory listing with ls -la, identify file types and permissions, and note owner, group, size, and last modified date, including dot files as dot bash_history.

  • Creating Directories3:45

    Create directories with mkdir, including nested subfolders using the -p option, verify with -R for recursive views, and use --help or -v to confirm creation.

  • Changing Directories5:16

    Learn to use cd and ls to navigate directories, switch between absolute and relative paths, move up with .., reach root or home, and use tab completion.

  • Renaming and Moving Files5:06

    Explore creating files with touch, listing and inspecting them with ls, and renaming or moving files with mv, including moving across directories and using asterisks to handle multiple files.

  • Copying and Removing Files6:01

    Learn to copy files with the cp command, including same-directory and cross-directory copies, and verify with ls -l. Master removing files with rm, using -i and -v, and empty-directory rules.

  • Working with Contents6:42

    Master basic file viewing and search in the terminal: view with cat, list with ls, and pipe through less or more, grep, head, tail, and wc to count and locate.

  • Working with Output3:01

    Explore how to read from standard input and redirect to standard output with the greater-than symbol, create and read files with cat, append data, and concatenate multiple files using cat.

  • Task 11:24

    Practice file operations by creating, appending, and concatenating word lists, then deleting and renaming files using standard input and output.

  • Working with Output. Part 27:45

    Master command-line output redirection and piping to connect commands, filter results with grep, sort listings, and capture who is logged in and other host information.

  • Section Quiz: Linux Command Line in 1 hour
  • Course Overview2:12

    Install virtual machine manager, review installation options and prerequisites, and inspect the imam console components and initial configuration tasks, including automation with PowerShell to modify VM properties.

  • Installing VMM6:46

    Install Virtual Machine Manager by running the setup, configuring the management server and console, and selecting a default installation location while addressing prerequisites, database, service account, and library templates.

  • An Overview of VMM UI11:11

    Explore the virtual machine manager user interface, its five component categories, and how the console integrates Windows PowerShell commands to manage tenants, clouds, fabric, library, and storage via jobs.

  • Initial Configuration Settings15:23

    Perform initial configuration in virtual machine manager, including enabling diagnostics, reviewing database connections, configuring library refresh, run-as accounts, service windows, and providers and extensions.

  • Automation And Scripting by Example13:46

    Explore how to automate virtualization tasks with PowerShell and Virtual Machine Manager, importing modules, scripting host property changes, and using jobs to track and restart tasks.

  • Bare Metal Deployment12:43

    Enable bare metal deployment with Virtual Machine Manager using Windows Deployment Services and IPMI to provision a Dell Hyper-V host running Windows Server 2016.

  • Introduction0:30

    Learn how to install a server, complete post-installation tasks, and perform remote management, with an introduction to server concepts and practical setup.

  • What is Nano Server?3:53

    Nano server is a compact Windows Server 2016 option with a smaller footprint, no local logon, and support for 64-bit apps and roles like Hyper-V host, DNS, and web server.

  • Overview of installing Nano Server8:27

    Learn to install nano server using the nano server image generator and PowerShell, and deploy it as a Hyper-V virtual machine or physical computer.

  • Demonstration: Installing Nano Server7:57

    This demonstration guides installing nano server on Windows Server 2016 using PowerShell, mounting installation media, copying .ps files, and running the nano server image generator to create a Hyper-V VM.

  • Demonstration: Completing post-installation tasks on Nano Server (Domain Join)6:06

    Completes post-install tasks on nano server, joins the server to the datum dot com domain, and configures remote PowerShell, firewall rules, and file transfers to finish the domain join.

  • Demonstration: Use Windows PowerShell to configure the settings of Nano Server2:36

    Use PowerShell to configure Nano Server, check and install features such as file server, connect remotely, verify network settings, review startup environment, and view default shares.

  • Demonstration: Performing remote management on Nano Server4:48

    Enable remote management with server manager on Nano Server, create an smb data share, and test the file and web server with a simple web page.

  • Creating an IIS website on Nano Server with PowerShell7:54

    Learn to connect to a nano server via PowerShell, import the IISAdministration module, and create and manage IIS websites, including creating a site called nano site dot com.

  • Introduction to PowerShell Key Concepts3:17

    Master PowerShell basics, core concepts, and command-line workflows, including pipelines, aliases, navigation, and using Get-Command and Get-Help to build scripts.

  • YAML 1011:22

    Explore the three core YAML structures and how indentation creates blocks. See how maps (dictionaries) and sequences (arrays) organize keys, values, and a unique identifier.

  • Basics of YAML Structure10:12

    Learn to read and write YAML configurations, master indentation and block versus flow styles, and use VS Code to build DevOps playbooks and scripts.

  • Using Online Parsers5:06

    Learn to use YAML and JSON online parsers to write and validate data, exploring key-value pairs, lists, dictionaries, and the impact of indentation on structure.

  • Choosing Text Editors and IDEs for YAML6:58

    Master significant whitespace in YAML by using spaces for indentation, avoiding tabs, and configuring editors like nano, vim, and VS Code to auto-indent and highlight syntax.

  • The Problem with Tabs3:59

    Learn how tabs become eight spaces and how hidden characters affect indentation in Linux text and YAML, and adopt consistent two-space indentation with editors like VS Code.

  • Creating a .nanorc File8:03

    Learn to use the nano editor to edit YAML files, set two-space indentation, convert tabs to spaces, save with control X, and enable YAML highlighting with a yaml nano rc.

  • Creating a .vimrc File and VSCode8:04

    Configure vim with a personal vimrc, enable syntax highlighting and YAML auto commands, and compare vim editing to using Visual Studio Code for large YAML files.

  • Basic Building Blocks of YAML Syntax10:27

    Explore the basic building blocks of YAML syntax, including block and flow styles for lists and mappings, scalar types, quotes, numbers, booleans, duplicates, and multi-document handling.

  • Practice Test: DevOps Tools
  • Bonus Lecture: What to Learn Next0:17

Requirements

  • Some basic Linux knowledge is helpful
  • A laptop or PC with Windows, macOS or Linux

Description

DevOps job adverts list a dozen tools, and nobody can learn them all at once. This course gives you a hands-on starter pack of the core ones in a single place, with each tool taught as a beginner module with demonstrations you can repeat on your own computer.

What the lectures cover

Besides the main topics, you also work through: See introductions to System Center Virtual Machine Manager, Nano Server and PowerShell key concepts.

Inside the course

The course is organised into these sections: Git; Ansible; Vagrant; Continue with Ansible Automation; Nginx; Kubernetes; Azure for Beginners; Python for Beginners; Starting with Python Scripts; Hands-On Python Scripts' Examples; Using Django and Flask; Linux Command Line in 1 hour; MS System Center: Intro to Virtual Machine Manager; Windows Nano Server 2016 with Powershell; PowerShell Key Concepts; YAML. Lectures you will find include: Introduction to Git.

The course runs about 17.3 hours in 190 lectures and includes one practice test of 40 questions. It is a broad starter pack, so each tool is covered at an introductory level and some modules are shorter versions of topics that deserve a full course of their own. Some of the material comes from our other courses on the same tools. Please check the curriculum if you already own those, so that you can skip the sections you know.

Who this course is for:

  • Starting DevOps engineers who want a wide first look
  • System administrators who want to see which tools to study next
  • IT engineers who need Git, Ansible and Python basics together