Course Taxonomy: Enterprise & Product Agility

Introduction to DevOps

Posted on October 17, 2020 by -

Part 1: Introduction        

  1. DevOps Defined
  2. High-Performance IT Organizations
  3. Core Chronic Conflict
  4. Exercise: Pain Points
  5. Business Value of DevOps
  6. Where DevOps Came From
    1. W Edwards Deming & Total Quality Management
    2. The Lean Movement & Toyota Production System
    3. The Agile Development & Infrastructure Movements
    4. Exercise: Agile Infrastructure
    5. The Continuous Delivery Movement
  7. IT Service management & DevOps
  8. End Goals of DevOps & CALMS

Part 2: Maturing a DevOps Practice in the Enterprise       

  1. DevOps & Organizational Culture
  2. Two Patterns You Can Follow
  3. The Involvement Principle
    1. Information Security Principles
  4. Exercise: The Involvement Principle
  5. Scaling DevOps in the Enterprise

Part 3: The DevOps Journey – The Three Ways

The First Way: Optimize Flow

  1. Principles of Flow
  2. Infrastructure As Code
  3. Infrastructure Configuration Mgmt & Tools
  4. Deployment Pipeline & Tools
  5. Shared Version Control & Tools
  6. Build Quality In
  7. Containerization
  8. SOA and Microservices
  9. Exercise: Optimizing Flow

The Second Way: Amplify Feedback

  1. Principles of Feedback
  2. Telemetry Principles
  3. System Monitoring Tools
  4. Log Aggregation & Tools
  5. Use Telemetry to Anticipate Problems
  6. Feedback For Safe Deployment of Code
  7. Hypothesis-Driven Development
  8. Exercise: Amplifying Feedback

The Third Way: Continual Learning & Experimentation

  1. Learning Culture
  2. Innovation Culture
  3. Exercise: Learning & Innovation Culture

Part 4: Course Conclusion   

  1. Q & A

Ansible Configuration Management Boot Camp

Posted on October 17, 2020 by -

Part 1: Introduction

  1. Why configuration management is a critical part of any DevOps team
  2. Strengths and weaknesses of Ansible
  3. Web-scale
    1. How Ansible is different from other CM tools like Chef and Puppet
    2. Getting started with Ansible terminology
    3. Ansible and YML for describing your environments

Part 2: Getting set up

  1. Some prerequisites
  2. Getting set up on a Mac
  3. Getting set up on Linux
  4. Getting set up on Windows
  5. Testing with Vagrant
  6. Using SSH keys to connect to your target nodes
  7. Hands-on Practice Lab: Install Ansible and test connectivity to your test nodes.

Part 3: Inventory

  1. Basic inventory example
  2. Hosts and groups
  3. Hands-on Practice Lab: Create an inventory file that defines four hosts, two web servers and two database servers, and assign these hosts to groups that describe their function.

Part 4: Ansible Playbooks

  1. A useful directory structure to keep your Ansible code organized
  2. Using git to manage your Ansible code
  3. A first look at a playbook to install and configure NTP time synchronization
  4. Hands-on Practice Lab: Create a playbook to install and configure OpenSSH-server on all nodes and make sure it is running.

Part 5: Provisioners

  1. Connecting Ansible to your preferred cloud provider (we'll use DigitalOcean)
  2. Creating a new server instance
  3. Dynamic inventory
  4. Dynamic inventory on Amazon AWS
  5. Mixing static and dynamic inventory
  6. Hands-on Practice Lab: Refactor your inventory so that your staging environment is local using Vagrant, and your production environment is built on DigitalOcean.

Part 6: Highly available infrastructure with Ansible

  1. Spec up our inventory and host groups
  2. Using roles
  3. Configure our database backend
  4. Configure our web server front-end
  5. Configure a replicated filesystem
  6. Configure centralized logging
  7. Hands-on Practice Lab: Build the sample infrastructure on your local Vagrant environment.

Part 7: Application deployments with Ansible

  1. Deploying our app from SCM to our local Vagrant environment
  2. How we would deploy that code to production once tested by QA
  3. Updating our application
  4. How Ansible compares to alternatives such as Capistrano
  5. Hands-on Practice Lab: Proceed with deploying our application on your local Vagrant environment.

Part 8: Docker containers with Ansible

  1. A brief intro to Docker
  2. The synergy of containerization and automation
  3. Using Ansible to build Docker containers
  4. MySQL containers
  5. Web application containers
  6. Data storage containers
  7. Hands-on Practice Lab: Adapt your infrastructure to deploy our sample app using Docker.

Part 9: Testing and continuous integration

  1. Unit, integration, and functional testing
  2. Automating your testing using GitHub and Travis CI
  3. Hands-on Practice Lab: Create some tests for our SSH playbook to make sure there are no syntax errors and that Ansible is configuring nodes as expected.

Part 10: Preparing for Ansible back at work

  1. Real-world use case: Using Ansible to automate CM and application pipelines through continuous integration, release, deployment, and operations
  2. We'll review your own environments and processes and evaluate how to best integrate Ansible's configuration management for your own needs
  3. Exercise: Your to-do list

SAFe Framework Overview

Posted on October 17, 2020 by -

Part 1: SAFe® Overview

  • What is SAFe?
  • Why SAFe?

Part 2: Applying SAFe Principles & Values

  • Lean-Agile Mindset
  • SAFe Core Values

Part 3: Executing SAFe in Cadence & Sync

  • Iteration Execution
  • Developing Cadence
  • Program Increment

Part 4: Continuous Delivery with SAFe

  • Inspect & Adapt
  • PI Planning
  • Shared Operations Teams

Part 5: Essential takeaways for Successful SAFe implementation

  • Roadmap
  • Next Steps

SAFe for Teams with Certified SAFe® Practitioner (SP)

Posted on October 17, 2020 by -

Part 1: Introducing SAFe

  1. Connect with the Scaled Agile Framework
  2. Explore Lean, the Agile Manifesto, and SAFe Principles
  3. Identify Scrum, Kanban, and Quality Practices

Part 2: Building an Agile Team

  1. Build your team
  2. Explore the Scrum Master and Product Owner roles
  3. Meet the teams and people on the Agile Release Train (ART)

Part 3: Planning the Iteration

  1. Prepare the backlog
  2. Plan the Iteration

Part 4: Executing the Iteration

  1. Visualize the flow of work
  2. Measure the flow of work
  3. Build quality in
  4. Continuously integrate, deploy, and release
  5. Improve flow with communication and synchronization
  6. Demonstrate value
  7. Retrospect and improve

Part 5: Executing the PI

  1. Plan Together
  2. Integrate and demonstrate together
  3. Learn together

Part 6: Becoming a Certified SAFe Practitioner

  1. Becoming a Certified SAFe® Practitioner (SP)

Test-Driven Development with Java

Posted on October 17, 2020 by -

Part 1: Agile Overview

Test Driven Development is a key component of the Agile Software Development Methodology and of the overall DevOps movement. So it is helpful to have at a minimum a high-level understanding of Agile practices and scrum ceremonies and TDD fits into the overall Agile, Scrum and DevOps landscape. Part 1 serves as a leveling exercise to ensure that team member is speaking the same language during upcoming labs and discussions.

  1. What is Agile Software Development
    • DevOps Overview
    • The Agile Manifesto
    • Scrum vs Agile
  2. Components of Agile
    • User Stories
    • Tasks
    • Bugs
    • Automated Builds
    • Automated Tests
    • Continuous Inspection
  3. The Role of TDD in Agile Development
    • Automated Unit Tests
    • Automated Acceptance Tests

Lab: Explore the Board of an Agile Project

  • Kanban Board
  • User Stories
  • Tasks
  • Bugs
  • Work in Progress
  • Burndown Chart

Part 2: Unit Testing

Unit Testing is a critical component of Test Driven Development (TDD). Small units of code are tested throughout the development process, which isolates functionality to ensure that individual parts work correctly.

  1. Unit Test Fundamentals
    • Reason to do Unit Testing
    • What to Test: Right BICEP
    • CORRECT Boundary Conditions
    • Properties of Good Tests
  2. Frameworks
    • What is JUnit
    • JUnit Building Blocks
    • Test Cases
    • Test Suites
    • Examples
  3. Agile Testing Strategy
    • Agile Testing Quadrant
    • Automation Pyramid
    • Assertions
  4. Test Attributes
    • Setup / TearDown
    • JUnit Lifecycle
    • System Under Test
    • Test Design Strategy
    • Naming our Tests
    • Exceptions

Lab: Introduction to Unit Testing

  • IDE and Project Setup
  • Running our first Unit Test
  • Explore Junit framework
  • Test Attributes
  • Assert Statements

Part 3: Test Driven Development

Essential TDD techniques require developers write programs in short development cycles, and there are critical steps that must be taken. Tests are created before the code is written. Once the code passes testing, it is refactored to adhere to the most effective and acceptable standards.

  1. TDD Rhythm
    • TDD Overview
    • Red, Green, Refactor
    • TDD Benefits
  2. Sustainable TDD
    • Development without TD
    • Test Last
    • Test Last in Parallel
    • Test Driven Development
  3. Supporting Practices
    • Collective Ownership
    • Continuous Integration
  4. Eight Wastes of Software Development
    • Ripple effect of defects
    • Partially Done Work
    • Extra Features
    • Relearning
    • Handoffs
    • Task Switching
    • Delays
    • Defects
  5. Test Automation
    • Automate, Automate, Automate
    • Automate Early and Often
    • Additional Topics Identified

Lab: Test Driven Development

  • Start Test Driven Development on our example App
  • Write unit test cases
  • Experience RED, Green, Refactor Process

Part 4: Principles of Agile Development

TDD is directly influenced by design, so it will be a priority to take this into context during implementation. Considering design principles will enable teams to experiment with different approaches, and gear towards more functional programming.

  1. Design Principles Overview
  2. Coding Principles
  3. isolation of the SUT
  4. Developing independently testable units
  5. Test doubles
    • Introducing test doubles
    • Stubs
    • Fakes
    • Mocks

Lab: Continue development on example App

  • Setting up Test doubles for our example app
  • Discuss and implement test dummy and test stubs

Part 5: Refactoring

Refactoring is another essential technique of TDD, and most software development teams are most likely doing some form of refactoring regularly. Refactoring can be used in a number of different workflows which will be explored in this Part.

  1. Why Refactor?
    • Red, Green, Refactor
    • Benefits
    • Development without TDD
  2. Refactoring Methods
  3. Refactoring Cycle
    • Reduce Local Variable Scope
    • Replace Temp with Query
    • Remove Dead Code
    • Extract Method
    • Remove Unnecessary Code

Lab: Continue our example project

  • Implement new test cases
  • TDD Cycle
  • Discuss and implement Refactoring Needs

Part 6: Pair Programming

Pair Programming is an effective way to improve code quality. In this Part, we will discuss pairing and how it leads to better software design, and a lower cost of development.

  1. Pair Programming
    • Pairing Setup
    • Results: Time
    • Results: Defects
    • How it works
  2. Advantages of Pairing
    • Both Halves of the Brain
    • Focus
    • Reduce Interruptions
    • Reduce Resource Constraints
    • Multiple Monitors
    • Challenges
  3. Pairing Techniques
    • Pair Rotation
    • Ping Pong Pairing
    • Promiscuous Pairs
    • Pair Stairs
    • Cross-Functional Pairing

Lab- Experience pair programming and continue developing our example app

Part 7: Acceptance Test Driven Development (ATDD) & Behavior-Driven Development (BDD)

Acceptance Tests are an important form of functional specification, and Behavior Driven Development dictates what happens as an effect of these tests being run. In this Part, we will cover the difference between them, and how they are closely related.

  1. Acceptance Testing
    • Acceptance Tests
    • Why Acceptance Tests?
    • Acceptance Test Execution
    • Who Writes Acceptance Tests
    • Pair Test Writing
  2. Best Practices for Effective Testing
    • Keys to Good Acceptance Tests
    • Writing Acceptance Criteria
    • Acceptance Test Example
    • Acceptance Test-Driven Development (ATDD)
  3. BDD vs. ATDD
    • Specification by Example
    • BDD Frameworks
    • BDD Examples

Lab: Experience ATDD and BDD

  • Experience ATDD or BDD and discuss the impact to TDD

Part 8: Advanced TDD

In order to implement Unit Tests efficiently, it is critical that developers understand their properties.

Lab: Demonstration for Mocking/doubles with our example App

  1. TDD Solutions
    • Continuous Unit Testing
    • Collective Ownership
  2. Advanced Unit Testing
    • Unit Testing Legacy Applications
    • Techniques for Legacy Code
    • External Dependencies
    • Mocking frameworks
    • Unit Testing the Database
  3. Outside In vs Inside Out
    • Working with database
    • Working with mocking frameworks
  4. Test Strategy
    • Continues Integration
    • Batch Execution of TestCases
  5. Unit Test Examples
    • More Tests
    • Algorithm
  6. Advanced Refactoring

Lab: Demonstration for Mocking/doubles with our example App

  • Working with database
  • Working with mocking frameworks

Part 9: Simulation

Experience Agile development with test driven development and pair programming

Test Automation Boot Camp (ICP-ATA)

Posted on October 17, 2020 by -

Part 1: Introducing Test Automation

  1. Watch an Automated Test
  2. Requirements
    1. Exercise: Identify different requirement types
    2. Exercise: Make requirements testable
  3. Testing Types
    1. Black-box vs. white-box
    2. System testing vs. integration testing vs. unit testing vs. acceptance testing
  4. Application Types
    1. Process-driven or data-driven: no "one size fits all"
    2. Exercise: Define different kinds of tests for different application types
  5. The Alphabet Soup of Tools and Methods
    1. Selenium. Gherkin. Cucumber. HPQC. Jira—you hear all of these. What do they mean? How do they fit together? Which do you need and which can you safely ignore?
    2. Exercise: Testing facts and fallacies

Part 2: Preparing for Test Automation

  1. Effective Partitioning Schemes
    1. Exercise: Structure a system into processes (actor goals), activities, actions
  2. Use Cases and Test Cases
    1. Exercise: Create a test case for a single activity from a written use case (happy path)
  3. Behavior-Driven Languages
    1. Exercise: Write a test case as a Gherkin scenario
  4. Modeling and Diagramming Techniques
    1. Exercise: Construct a UI navigation map for normal and alternate flows
  5. Equivalence Partitioning and Boundary Value Analysis
    1. Exercise: Define input value choices and use TAME to construct test alternatives

Part 3: Recording Automated Tests

  1. Automated Test Steps:
    1. Pre-checks, Inputs, Events, and Post-Checks
    2. Exercise: Write the steps of an automated test
  2. Record and playback a single test
    1. Exercise: Record and play back a test in Selenium WebDriver

Part 4: Dissecting Automated Tests

  1. Recorded Test Steps
    1. Exercise: Examine recorded steps in Selenium
  2. UI Element Repositories
    1. Exercise: Examine the components of a UI page
    2. Exercise: Create path expressions to locate page elements

Part 5: Assembling Automated Tests from Modules

  1. Test Suites, Test Cases, and Modules
    1. Exercise: Partition a recorded test into reusable modules
  2. Modular Test Development
    1. Exercise: Construct test cases from existing modules
    2. Exercise: Construct new modules for alternate behaviors

Part 6: Coding Automated Tests

  1. Code always, Code sometimes, or Code never
  2. The Skills Pyramid
  3. Open-source and commercial tools
    1. Exercise: Compare tools and team capabilities

Part 7: Exploiting Automated Testing

  1. Test-driven development: test cases as specifications
  2. Data-driven tests
    1. Exercise: Define data tables for equivalence partitions and boundary value analysis
  3. Multi-platform and cross-browser testing
    1. Exercise: Run test cases on multiple web browsers

Part 8: Enabling Continuous Integration with Test Automation

  1. Regression test suites
  2. Development events trigger test runs
  3. Configure test subsets
    1. Exercise: Define a minimal "smoke test" and contrast with a full regression suite
  4. Report test results
    1. Exercise: Design a dashboard for quick reporting of test results

Part 9: Course Summary

  1. Quiz: Testing facts and fallacies
  2. Exercise: Plan your own test automation strategy

Git & GitHub Boot Camp

Posted on October 17, 2020 by -

Part 1: Git – Basic and Advanced Commands

1. Getting started with Git & GitHub

  • Why Git?
  • Installing Git on Windows
  • Installing Git on Mac
  • Installing Git on Linux
  • Signing up to GitHub
  • HTTPS
  • SSH
  • Understanding Git

2. Basic Git Commands

  • Configuration
  • Initializing a repository
  • Adding commits
  • Adding a remote
  • Pushing to the remote
  • Fetching from the remote
  • Pulling from the remote
  • Creating a branch
  • Merging
  • Cloning
  • Reset
  • Revert

3. Advanced Git Commands

  • Amending commits
  • Rebasing
  • Interactive rebasing
  • Cherry-picking
  • Bisect
  • Aliases
  • Hooks
    • Git hooks allow you to run scripts before or after certain Git actions (e.g., modify the commit message prior to committing).

Part 2: GitHub – Team and Enterprise Applications

1. Getting started with GitHub

  • Two-factor authentication
  • Searching GitHub
  • Starring repositories
  • Following people
  • Watching repositories
  • Commit email addresses
  • Notifications

2. Options for teams

  • Organization accounts
    • Organization accounts allow you to combine multiple GitHub users into an organization. A single GitHub user can be a member of several organizations. A repository can also be owned by an organization instead of a single user.
  • Teams
    • Organization accounts allow you to combine multiple GitHub users into an organization. A single GitHub user can be a member of several organizations. A repository can also be owned by an organization instead of a single user.
  • Paid plans
    • GitHub offers a lot of functionality for free. But companies often need more. The paid plans allow things like private repositories, fine-grained access control, extra support, etc.

3. Working in teams

  • GitHub Flow
    • GitHub Flow is an easy branching strategy. It starts from a master branch and creates only feature branches from there. The feature branches only get merged into the master branch when approved and ready for release. This allows a team to have a rapid cadence of releases, but it also creates some requirements that need to be addressed. For example, you will need a good CI/CD pipeline, a business that accepts rapid releases, possibly a good feature toggle system, etc.
  • Git Flow
    • GitFlow is a more complex branching strategy but allows for a more secure development and deployment pace. It's often more fit for larger enterprises. Luckily, there are CLI plugins and GUI tools that support GitFlow and make it easy to work with. This way, developers don't have to remember the specific commands and branching flows.
  • Documentation
  • Issues
  • Projects
    • GitHub projects give teams a Kanban board to organize and visualize their work. It's a step up from GitHub Issues.
  • Releases
    • Git allows developers to create tags in their repositories. In GitHub, you can easily link these tags to "Releases." A release can contain release notes, providing a nice overview of what changed over time.

The Power of the Product Owner

Posted on October 17, 2020 by -

Part 1: Product Journey – Where are we going?

1.From project to product

2.The concept of “product ownership”

3.Product roadmaps – Who? What? Why

  • Balancing competing interests
  • Charting a course for “Product Agility”

Part 2: The Role of the Product Owner

1.Before agile… after agile…

2.How do you build great PO’s?

  • Technical skills
  • Soft skills
  • Flavors of PO’s

3.The order taker dilemma

4.Building balanced PO teams

5.Working with other players on the product team

Part 3: Blending Product Discovery and Delivery

1.Roadmap -> Backlog -> Work Item

2.Early discovery – When? Why? How?

  • Release cadence
  • From concept to journeys

3.Discovery/Delivery cadence

  • What? Why? How?
  • Sprint cadence
  • From journeys to stories and tests
  • “How big?” to “Too big?”

4.Want more from your team? Build a better backlog

  • Tactics
  • Incremental investment, measuring impact, and adjusting

5.How much involvement is too much or too little?

Advanced Certified Scrum Product Owner® (A-CSPO®)

Posted on October 17, 2020 by -

Part 1: Product Owner Core Competencies

  • The importance of the product ownership
  • The mindset and Actions of a Product Owner
  • Interacting with Stakeholders
  • Product Owners as facilitators
  • Facilitation techniques
  • Facilitation of conversations with Stakeholders
  • Understanding the risk of technical debt
  • Understanding the importance of development practices
  • Recognize approaches to scaling scrum
  • Visualizing and reducing dependencies
  • Benefits of Feature Teams

Part 2: Advanced Goal setting and planning

  • Operationalizing Product Strategy
  • Approaches to define product strategy
  • Product Planning
  • Visualizing and communication Strategy, ideas, and features

Part 3: Empathizing with Customers and Users

  • Connecting Developers with Customers
  • Customer product discovery techniques

Part 4: Advanced Product Assumption Validation

  • Recognize cognitive biases
  • Improving your Sprint Review
  • Defining Hypotheses
  • Planning how to test hypotheses
  • Validating assumptions in Scrum

Part 5: Product Backlog Management

  • Techniques for measuring value
  • Techniques for ordering Product Backlogs
  • Getting enough Product Backlog items ready
  • Improving Product Backlog Refinement

Introduction to Kubernetes

Posted on October 17, 2020 by -

Part 1: Prerequisites – Kubernetes Foundations

  1. Containers
  2. Linux Kernel Features
  3. Container User Experience
  4. New Container Capabilities
  5. Gaps using Containers in Production
  6. Microservices
  7. DevOps

Part 2: Core Concepts of Kubernetes

  1. Cluster Orchestration
  2. Looking at K8S Origination at Google
  3. Open Source
  4. Benefits
  5. Design Principles

Part 3: Navigating Kubernetes Architecture

  1. Master/Node
  2. Kubectl
  3. Replication Controller
  4. Kubelet
  5. Kube-Proxy
  6. Persistent Volumes
  7. Etcd
  8. High Availability

Part 4: Using Kubernetes Features

  1. Pods
  2. Labels
  3. Services
  4. Namespaces
  5. Resource Quota

Part 5: Security and Kubernetes

  1. Goals
  2. Roles
  3. Attribute-Based Access Control
  4. Policies
  5. Service Accounts
  6. Secrets

Part 6: Networking and Kubernetes

  1. Docker Networking
  2. Kubernetes Networking
  3. Pod to Pod
  4. Exposing Services
  5. IP Per Pod
  6. Inter Pod Communication
  7. Intra Pod Communication

Part 7: Cluster Add-ons

  1. Cluster DNS
  2. Logging with Elasticsearch and Fluentd
  3. Container Level Monitoring
  4. cAdvisor
  5. InfluxDB
  6. Prometheus

Part 8: Practical Kubernetes Examples

  1. Hello World
  2. WordPress         
  3. Guestbook
  4. 3 Tier App
  5. Http/Https Load Balancing

Part 9: Continuous Integration with Kubernetes

  1. Canary Release
  2. Blue Green Deployment
  3. A/B Testing
  4. Rolling Update
  5. Jenkins Plugin

Part 10: Roadmap/Beta

  1. Ingress
  2. Deployments
  3. Autoscaling
  4. Jobs
  5. DaemonSets
  6. Network Plugins
  7. DNS

Part 11: Class conclusion – Implementation, Q and A, Next Steps

  1. Discussion: What can you apply?
  2. How can Kubernetes help your situation
  3. Expert Q and A