Course Taxonomy: Technology Platforms

Managing AWS Infrastructure with Terraform

Part 1: Infrastructure as Code

In this section, we will introduce the benefits that Infrastructure as Code (IaC) can bring to organizations and how IaC fits within modern DevOps best practices.

  • Motivation for Infrastructure as Code
  • Applying Infrastructure as Code in DevOps
  • Infrastructure as Code principles and best practices
  • Benefits of Infrastructure as Code
  • The case for Terraform

Part 2: Terraform Overview

This section provides an overview of Terraform concepts and vocabulary and instructs how Terraform manages infrastructure configuration in cloud environments.

  • Terraform architecture
  • Terraform configuration language overview
  • Terraform CLI
  • The lifecycle of a configuration
  • Managing configuration state

Hands-on Labs:

  • Using the Terraform CLI
  • Setting up a Terraform project

Part 3: AWS Resources

In this section, participants will get hands-on practice using Terraform to create a simple application environment in AWS and learn the essential constructs in Terraform for defining resources.

  • Resource types
  • Best practices in declaring resources
  • Network resources (VPC, subnet, security group)
  • Compute resources (virtual machine)
  • Storage resources (database)
  • Local values in a configuration
  • Augmenting a configuration with data sources

Hands-on Labs:

  • Creating a VPC and subnets
  • Adding a virtual machine into your VPC
  • Adding a database to your VPC
  • Using locals for replicated values
  • Using a data source to read external configuration

Part 4: Terraform Programming

This section introduces programming constructs within Terraform that enable you to add more control and flexibility in defining resources.

  • Data structures (primitives, maps, lists, objects, etc.)
  • Types of expressions to set values
  • Creating multiples of a resource
  • Dynamic blocks
  • Parameterizing a configuration with variables
  • Outputs from a configuration
  • Functions
  • Handling errors

Hands-on Labs:

  • Using variables in a configuration
  • Getting outputs from a configuration
  • Creating a re-sizable cluster of virtual machines
  • Creating multiple resources through iteration loops
  • Leveraging functions in your code

Part 5: Modules

This section shows how modules can be used to create reusable components in Terraform and teaches best practices in organizing Terraform code.

  • Purpose of modules
  • Module structure and code organization
  • Invoking modules
  • Module sources and versioning
  • Nested modules
  • Publishing modules

Hands-on Labs:

  • Using an external module in your configuration
  • Refactoring your code to implement a module

Part 6: Wrapping Up

This section wraps up the course with reviews to reinforce what you have learned.

  • Reference material to learn more
  • Course review
  • Next steps

Mastering DAX for Microsoft Power BI

Part 1: Introduction to DAX

  1. What is DAX?
  2. Why use DAX with Power BI
  3. Calculated Columns vs Measures
  4. Types of Functions
    1. Logical Functions
    2. Table manipulation functions
    3. Date and time functions
    4. Filter functions
    5. Financial functions
    6. Math and Trig functions 
    7. Parent and Child functions
    8. Relationship functions 
    9. Statistical functions
    10. Text functions
    11. Time intelligence functions

Part 2: Logical functions

  1. TRUE
  2. FALSE
  3. IF
  4. IFERROR
  5. AND
  6. OR
  7. SWITCH
  8. COALESCE

Part 3: Tables

  1. Tables Overview
  2. Filtering Tables
    1. FILTERS
    2. TOPN
  3. Summarizing Tables
    1. SUMMARIZE
    2. SUMMARIZECOLUMNS
    3. ROLLUP
    4. GROUPBY
  4. Generating Tables
  5. Distinct Values
    1. DISTINCT column
    2. DISTINCT table
  6. Joining Tables
    1. CROSSJOIN
    2. NATURALINNERJOIN
    3. NATURALLEFTOUTERJOIN
  7. Adding Values
    1. Columns
    2. Missing items
  8. Table Constructor

Part 4: Date and Time Functions

  1. Date and Time Functions Overviews
  2. Units of Time
  3. Creating a Calendar
    1. CALENDAR
    2. CALENDARAUTO
  4. Dates
  5. TODAY
  6. NOW
  7. TIME
  8. TIMEVALUE

Part 5: Filter Functions

  1. Filter Functions Overview
  2. Filtering Tables
    1. FILTER
    2. REMOVEFILTERS
    3. ALL (ALL, ALLCROSSFILTERED, ALLEXCEPT, ALLNOBLANKROW, & ALLSELECTED)
    4. CALCULATETABLE
    5. KEEPFILTERS
  3. CALCULATE
  4. LOOKUPVALUE
  5. SELECTEDVALUE

Part 6: Financial functions

  1. Accrued Interest
    1. ACCRINT
    2. ACCRINTM
  2. Depreciation
    1. DB
    2. DDB

Part 7: Relationships Functions

  1. CROSSFILTERS
  2. RELATED
  3. RELATEDTABLE
  4. USERELATIONSHIP
  5. Parent and Child Functions
    1. PATH
    2. PATHCONTAINS
    3. PATHITEM
    4. PATHITEMREVERSE

Part 8: Text functions

  1. FIND
  2. SEARCH
  3. REPLACE
  4. FORMAT
  5. LOWER
  6. UPPER
  7. RIGHT
  8. LEFT
  9. COMBINEVALUES
  10. CONCATENATE
  11. CONCATENATEX
  12. EXACT
  13. FIXED
  14. LEN
  15. MID
  16. SUBSTITUTE
  17. TRIM
  18. VALUE

Part 9: Statistical functions

  1. Central Tendencies
    1. Averages
    2. Means
    3. Geo means
  2. Counting
    1. Counting and COUNTX
    2. Blanks, and rows
    3. Distinct count: distinct, approximate, no blank
  3. Min/Max
    1. MAX, MAXA and MAXX
    2. MIN, MINA and MINX
  4. Sample
  5. Distributions
    1. Normal
    2. Exponential
    3. Beta
    4. Poisson
  6. Inverse
  7. Percentiles
  8. Ranking
  9. Standard Deviation
  10. Variance
    1. VAR.P and VARX.P
    2. VAR.S and VARS.P

Deploying and Automating Infrastructure at Scale

Part 1 – Infrastructure Platform: AWS Cloud

  1. Installing and using the AWS CLI (Command Line Interface)
  2. AWS Networking
  3. VPC’s (Virtual Private Clouds)
  4. Subnets
  5. Internet Gateways
  6. Route Tables
  7. Route Table Associations
  8. Creating AWS Networking Components
  9. Launching VMs in AWS Cloud

Part 2 – Git: Source Control Management: GitHub

  1. This course doesn’t teach the basics of git. Git experience is assumed (see the ‘DevOps Pipeline’ course if your team needs basic git knowledge)

Part 3 – Infrastructure Deployment: Terraform

  1. Intro to Terraform
  2. Creating cloud buckets for storage
  3. Separating code: Multiple Terraform configuration files
  4. Storing state remotely
  5. Git branching
  6. Displaying resource outputs
  7. Creating cloud networking components with Terraform
  8. Configuring cloud Security groups
  9. Using SSH Public/Private Keys with Terraform
  10. Launching and Destroying cloud VM instances with Terraform
  11. Creating reusable code with modules
  12. Using Terraform variables

Part 4 – Configuration Management: Terraform with Ansible

  1. Ansible Provisioners in Terraform
  2. Integrating Terraform-managed instances with Ansible Control Nodes
  3. Launching multi-tiered architectures (web servers and load balancers) with Terraform and Ansible

Part 5 – Notifications: Slack

  1. Integrating CI/CD with Slack
  2. Using Slack for CI/CD approvals and notifications

Part 6 – Containerization: Docker

  1. Purpose and use case for Docker
  2. Docker Hub
  3. Basic Docker commands
  4. Docker Networking
  5. Launching and debugging NGINX containers
  6. Mounting Volumes to containers
  7. Docker mount points: Multiple containers, one shared code location
  8. Launching Docker hosts and Docker containers automatically
  9. Port mapping with containers
  10. Launching multi-tiered architectures (web servers and load balancers): an automated approach
  11. Customizing containers with Docker Hub and Dockerfiles
  12. Reducing infrastructure bloat: Buster-Slim Docker containers

Part 7 – Managed OS: Linux Only

  1. Management of Linux Servers only

Part 8 – Container Management: Kubernetes (Optional)

  1. Kubernetes (K8S) overview and use case
  2. K8S architecture
  3. Installation and configuration
  4. Master and node server components
  5. Creating K8S load-balanced clusters
  6. Deploying Apps with K8S
  7. Scaling Apps
  8. K8S monitoring and App repair
  9. Updating Apps with K8S

Building Microsoft Power BI Dashboards

Part 1: What is BI?

We’ll start out by covering business intelligence basics to lay the groundwork for an intelligent approach to reporting and visualizing data.

  • Business Intelligence Overview
  • Common Challenges
  • Benefits of Power BI

Part 2: Getting started with Power BI

Power BI is an extensive toolbox for working with and analyzing data. We’ll cover the fundamentals of the service, how Power BI’s features are organized, and immediately orient towards dashboards and visualization.

  • Overview & Pricing/Licensing
  • Components of Power BI
  • Building Blocks of Power BI
  • Quick Tour of Power BI Service

Part 3: Building simple reports

Reports are the first step in graphically communicating information related to your data. In this section of the class, you’ll learn to use and navigate the types of datasets you encounter every day, and how to use them to begin shaping meaningful communication.

  • Importing excel data
  • Using preexisting datasets
  • Creating visualizations
  • Using slicers

Part 4: Dashboards

In this section, we’ll cover how to create and use dashboards for common needs. By the end of this section, you’ll understand what’s realistic to expect from your PowerBI dashboards and how to set them up, share them, and produce valuable insights with your team quickly.

  • Dashboard expectations vs. features
  • Using KPI
  • Create and Configure a Dashboard
  • Shared Dashboards with your Organization
  • Pinning visuals

Part 5: Exploring data

In this final section of class, we’ll get a bit more granular about navigating, analyzing and communicating about your data. By the time we conclude, you’ll be ready to start applying what you’ve learned in your own real-world situations. 

  • Use Quick Insights
  • Display Visuals and Tiles Full-Screen
  • Edit Tile Details
  • Get More Space on Your Dashboard
  • Ask Questions of your Data with Natural Language
  • Advanced Navigation

Implementing Azure DevOps Pipelines

Part 1: Course Introduction

  1. Azure Repos-Chef-Azure Pipelines: A DevOps Pipeline
  2. Course Purpose
  3. Agenda
  4. Introductions
  5. Lab Environments

Part 2: Technology Overview

  1. Git – Source Control Management
  2. Chef – Configuration Management
  3. Azure Pipelines – Continuous Integration
  4. An End-To-End CI/CD (Continuous Integration/Continuous Deployment) Pipeline

Part 3: Git/Azure Repos – Source Control Management

  1. Git purpose and Workflow
  2. Git configuration
  3. Getting help with git
  4. Basic git commands
  5. Remote, status, add, commit, push, log, diff
  6. Creating and checking out branches
  7. Creating a repository in Azure Repo
  8. Accessing a private repository with SSH keys
  9. Pull requests
  10. Merging and deleting branches

Part 4: Chef – Configuration Management

  1. Chef purpose and use cases
  2. Chef basics: Resources, recipes, and cookbooks
  3. Chef policy files
  4. Integration testing with Inspec and Test kitchen
  5. Chef variables: Attributes and Ohai
  6. Dynamic file creation with templates
  7. Using Chef Supermarket and community cookbooks
  8. Wrapper cookbooks
  9. Automating infrastructure with Chef Search
  10. Centralized management with Chef Infra Server
  11. Automating Chef convergence
  12. Managing nodes with policy groups

Part 5: Azure Pipelines

  1. CI/CD = Continuous Integration / Continuous Deployment
  2. Purpose
  3. Projects
  4. Jobs
  5. YAML scripting – CI/CD as Code
  6. Managing credentials and secret files
  7. Integrating with Source Control Management: Azure Repos
  8. Triggers: Scheduled Polling and Webhooks
  9. Automated cookbook linting: Foodcritic and Cookstyle
  10. Automated cookbook testing with Test Kitchen
  11. Azure Pipelines Integration with Chef Server
  12. Creating Separate Build and Release Pipelines
  13. Continuous Deployment of Chef cookbooks with Azure Pipelines

Implementing a CI/CD Pipeline

Part 1: Technology Overview

  1. Git – Source Control Management
  2. Ansible – Configuration Management
  3. Jenkins – Continuous Integration/Continuous Deployment

Part 2: Git – Source Control Management

  1. Purpose overview and use cases
  2. Git workflow
  3. Configuring git on your local machine
  4. Getting help with Git
  5. Local vs. Global vs. System configurations
  6. Basic Git Commands
  7. Creating local git repositories
  8. Branching and merging
  9. Using remote repositories
  10. Pushing code to Github using public and private SSH keys

Part 3: Ansible – Configuration Management

  1. Ansible purpose and use cases
  2. Architecture and call flow
  3. Ansible installation, configuration, and validation
  4. Control nodes and managed nodes
  5. Ansible managed hosts
  6. Host inventory; hosts and groups
  7. Repeatable code: Playbooks
  8. Introduction to YAML
  9. Modularizing code: Roles
  10. Ansible variables
  11. Dynamic configuration with facts
  12. Finding errors: Ansible unit testing
  13. Ensuring code quality: Ansible integration testing

Part 4: Jenkins – Continuous Integration / Continuous Deployment

  1. CI/CD overview, use cases and history
  2. Plugin architecture
  3. Initializing a Jenkins server
  4. Projects and jobs
  5. Freestyle jobs
  6. CI/CD as Code: Pipeline projects
  7. Declarative vs. scripted pipelines
  8. Jenkins Environment variables and parameters
  9. Distributed architecture: Master and agent nodes
  10. Views and Folders
  11. Managing credentials and secrets
  12. Integrating with git Source Control Management
  13. Triggers: Webhooks and Polling
  14. Notifications: Instant messaging and SMTP Email
  15. Approval inputs
  16. Testing Ansible playbooks in Jenkins
  17. Multibranch Pipelines: Reading entire repositories
  18. Conditional Logic
  19. Deploying Ansible playbooks with Jenkins: An automated end-to-end deployment pipeline

Jenkins User Boot Camp (Java/Python)

Part 1: Source Control Management with Git

  1. Purpose and overview of Git
  2. Use cases for Git
  3. Git flow
  4. Git providers
  5. Git configuration
  6. Finding help on Git
  7. Creating Local Git Repositories
  8. Basic Commands: add, commit, status, log
  9. Comparing commits: git diff
  10. Using a Repository: git push
  11. Branches: creating, merging and deleting
  12. Resolving merge conflicts
  13. Managing Pull Requests
  14. Using SSH keys with git platform private repositories

Part 2: Continuous Integration/Continuous Deployment with Jenkins

  1. Continuous Integration / Continuous Delivery (CI/CD): Jenkins
  2. CI/CD = Continuous Integration / Continuous Deployment
  3. Jenkins use case, purpose & history
  4. Architecture
  5. Using Plugins
  6. Initializing a Jenkins Master
  7. Projects / jobs
  8. Freestyle UI jobs
  9. CI/CD as Code: Pipeline Projects
  10. Declarative versus Scripted pipelines
  11. Views and folders
  12. Managing credentials and secrets
  13. Distributing workloads – Master and Agent nodes
  14. Integrating with Git: Source Control Management
  15. Triggers: Scheduled Polling and Webhooks
  16. Notifications: Instant Messaging Integration
  17. Requiring human input and approval
  18. Automated code linting and testing
  19. Jenkins Integration with managed nodes
  20. Continuous deployment through Jenkins

Part 3: Code Deployment and Release Management

  1. Java
    1. Building an artifact
    2. Storing Artifacts locally
  2. Python
    1. Building an artifact
    2. Storing Artifacts locally

Part 4: Notifications with Slack

  1. Integration setup
  2. Using Slack for CI/CD notifications

Part 5: Linux Management

Splunk Boot Camp

*All lab exercises are run in a Linux environment. A Windows environment can be provided upon request. 

Part 1: Introduction to Splunk

  1. What’s Splunk?
  2. Authentication Methods
  3. Access Controls & Users
  4. Products, Licensing, and Costs
  5. Quick Tour Guide: User Interface
  6. Exercise: Lab Environment and Configuration

Part 2: Indexes

  1. Splunk Data
  2. What are Indexes?
  3. What are Indexers?
  4. Exercise: Create Your First Index
  5. Search-Head
  6. Index Clusters
  7. Index Pipeline
  8. Exercise: Upload Data Manually
  9. Events
  10. Fields & Field Extraction
  11. Exercise: Using the Field Extractor Tool
  12. Forwarders
  13. Metrics
  14. Exercise: Using the Forwarder to Send Data
  15. Removing Data

Part 3: Splunk Architecture

  1. Components of Splunk Deployments
  2. Deployment Scenarios

Part 4: Search Processing Language

  1. What is Search Processing Language (SPL)?
  2. Searching Operators
  3. Search Commands
  4. Search Pipeline
  5. Exercise: Search Examples
  6. Subsearches
  7. Commonly Used Search Commands
  8. Exercise: Search Examples II
  9. Drilldowns
  10. Lookups
  11. Exercise: Using Lookups
  12. Optimize Searches
  13. Exercise: Search Examples III

Part 5: Dashboard & Visualizations

  1. Dashboards in Splunk
  2. Creating Dashboards
  3. Visualization Types
  4. Search as Reports
  5. Dashboards
  6. Exercise: Creating a Dashboard
  7. Drilldown
  8. Forms
  9. Exercise: Add Input Forms
  10. Exercise: Drilldown

Part 6: Alerts

  1. Creating Alerts
  2. Scheduling Alerts
  3. Alerts Notifications
  4. Exercise: Creating Alerts

Part 7: Scheduled Reports

  1. Creating Scheduled Reports
  2. Exercise: Create a Scheduled Report

Part 8: Putting All Pieces Together

Exercise: As a final lab, you’ll configure a typical scenario when using Splunk. You'll install and configure an NGINX, then the Splunk forwarder to collect logs in Splunk. The idea is that you can apply everything you've learned within the Bootcamp: creating searches, visualizations, dashboards, etc.

Advanced Kubernetes Boot Camp

Part 1: Core Concepts

We’ll go deep into different terms of Kubernetes to understand what it takes to build and run scalable systems in production. There are design patterns that you can implement in Kubernetes to extend an existing application without having to change the source code, like a sidecar pattern.

  1. Kubernetes architecture
  2. Imperative commands and descriptive manifests
  3. Pods, deployments, services, namespaces, DaemonSets
  4. Exercise: Working with Pods
  5. Exercise: Working with ReplicaSet
  6. Exercise: Working with Deployments
  7. Exercise: Working with Services
  8. Multi-containers
  9. Init containers
  10. Exercise: Working with StatefulSet
  11. Working with multiple clusters (kubeconfig)
  12. Kubernetes design patterns

Part 2: Networking in Kubernetes

Understanding how networking works in Kubernetes is important because it will help you to configure networking patterns like service discovery for a microservices architecture. But another concept that is taking more relevance are service meshes. We’ll explore what a service mesh is, and we’ll practice using one of the most popular ones: Istio.

  1. Ingress networking
  2. Exercise: Working with Ingress
  3. Networking policies
  4. Exercise: Working with Networking Policies
  5. What’s a service mesh?
  6. Introduction to Istio
  7. Observability with Istio
  8. Networking security with Istio
  9. Canary releases with Istio
  10. Exercise: Working with Istio

Part 3: Creating Scalable and Fault-Tolerant Applications

Kubernetes has a lot of great features built in by implementing the controller pattern. But in many cases, our applications need to include small configurations to help Kubernetes make better decisions to support reliable applications. We’ll see what changes are needed in the applications, and then we’ll deploy and test a sample application.

  1. Working with configuration
  2. Exercise: Working with ConfigMaps
  3. Working with probes
  4. Exercise: Working with Probes
  5. Configuring requests and limits
  6. Taints and tolerations
  7. Exercise: Working with Taints and Tolerations
  8. Node selectors
  9. Configuring scaling policies
  10. Exercise: Configuring scaling policies

Part 4: Development Workflow in Kubernetes

Kubernetes doesn’t have to change the way developers build applications, but they might want to be involved or test in their local workstations when they’re done with their application changes. We’ll discuss some recommended practices and tools.

  1. Packaging and managing applications with Helm
  2. Exercise: Working with Helm
  3. Continuous delivery in Kubernetes
  4. Exercise: Continuous Delivery with Flux
  5. Logging and monitoring systems
  6. Troubleshooting application failures
  7. Exercise: Troubleshooting Applications
  8. Development Toolbox: State of the art

Part 5: Developing Stateful Services

Stateless services are great for certain use cases, but there are scenarios where an application needs to be able to store data permanently, or at least work with data that is not ephemeral. Databases are one example.

  1. Understanding persistent volumes
  2. Exercise: Working with PV and PVC
  3. Backup and restore in Kubernetes
  4. Exercise: Backup and restore with Velero
  5. Databases in Kubernetes

Part 6: Security Practices and Recommendations

Kubernetes is not secure by default, and there are many considerations that you need to be aware of if before exposing your applications to the public internet. Companies usually have existing security policies, so we’ll cover how these security practices apply in a Kubernetes ecosystem.

  1. Authentication and Authorization
  2. Integration with AWS and IAM
  3. Docker image and pods security
  4. Pod Security Context and Policies
  5. Secrets encryption using KMS
  6. Exercise: Security in Kubernetes

Part 7: Extending the Kubernetes API

There are times where we need to extend the Kubernetes API to operate systems more easily. Not everyone will need to build something to extend the Kubernetes API, but it’s very valuable to understand the what, when, and how of custom resource definitions and the operator pattern.

  1. Custom Resource Definition (CRD)
  2. Custom Controllers
  3. Operator Pattern
  4. Operator Framework
  5. Exercise: Creating an Operator

Part 8: What’s Next for Kubernetes?

We’ll discuss other topics related to Kubernetes that might not fit everyone’s use cases, but that as a Kubernetes user you might want to be aware of. For instance, we’ll talk a little bit about having federated clusters, hybrid workloads, and several important tools from the CNCF.

Managing Azure Infrastructure with Terraform

Part 1: Infrastructure as Code

In this section, we will introduce the benefits that Infrastructure as Code (IaC) can bring to organizations and how IaC fits within modern DevOps best practices.

  1. DevOps and GitOps
  2. Principles of Infrastructure as Code
  3. Applying Infrastructure as Code in DevOps
  4. Infrastructure as Code best practices
  5. Benefits of Infrastructure as Code
  6. The case for Terraform

Part 2: Terraform Overview

This section provides an overview of Terraform concepts and vocabulary and instructs how Terraform manages infrastructure configuration in cloud environments.

  1. Terraform configuration language overview
  2. Terraform CLI
  3. The lifecycle of a configuration
  4. State storage – local versus remote
  5. Connecting to Azure

Hands-on Labs:

  • Setting up a Terraform project

Part 3: Azure Resources

In this section participants will be getting hands-on practice using Terraform to create a simple application environment in Azure, learning the essential constructs in Terraform for defining resources.

  1. Resource metadata and naming best practices
  2. Subscription and resource group
  3. Networking resources (VNet, subnet, network security group)
  4. Compute resources (virtual machine)
  5. Storage resources (storage account, file share, blob storage)
  6. Database resources (SQL database)
  7. Variables
  8. Outputs

Hands-on Labs:

  • Deploying a VNet
  • Adding a virtual machine into your VNet
  • Adding storage and a database
  • Including variables in your code
  • Using Terraform commands to validate and inspect your configuration

Part 4: Terraform Programming

This section introduces programming constructs within Terraform that enable you to add more control and flexibility in defining resources.

  1. Control operations (count, loops, conditional, depends_on, etc.)
  2. Data structures (maps, lists, random_string, etc.)
  3. Data sources
  4. Functions (e.g., lookup, coalesce, join, merge, etc.)
  5. Variable validation
  6. Debugging Terraform

Hands-on Labs:

  • Managing multiple resources through count and loops
  • Using maps and lists in your code
  • Using functions in your code
  • Using Terraform CLI and state manipulation to debug your configuration

Part 5: Modules

This section shows how modules can be used to create reusable components in Terraform and teaches best practices in organizing Terraform code.

  1. Purpose of modules
  2. Modules code file organization structure
  3. Module structure
  4. Module sources and versioning
  5. Nested modules
  6. Publishing modules

Hands-on Labs:

  • Refactoring your earlier lab code to a module
  • Using Azure modules (subscription, metadata, resource group, virtual network)

Part 6: Wrapping Up

This section wraps up the course with reviews to reinforce what you have learned.

  1. Reference material to learn more
  2. Course review
  3. Next steps