• duration
    2 days
  • Hands-On
    Labs
  • Customized
    Courseware
  • Wide Range of DevOps tool set
    DevOps tools

At its essence, DevOps is a culture, a movement, a philosophy.

DevOps – Introduction to Microservices Boot Camp

This Introduction to Microservices training course will help you understand the value proposition and technical aspects of microservices, a new and rather fuzzy concept used to describe rapidly provisionable, independently deployable services with narrow and distinct functionality.

Upon completion of this Microservices training course, students will have a fundamental understanding of microservices and practical experience in implementing microservices using different technology stacks.

Course Objectives

In this Boot Camp training, attendees will learn:

-Microservices
-Docker
-RESTful Web Services
-Node.js
-Spring Boot
-Kubernetes
-OpenShift

AUDIENCE

For IT professionals, developers, software engineers, and DevOps practitioners – our microservices training provides the technical practices and tooling fundamentals necessary to begin realizing the benefits of microservices as a foundation for IT architecture, software engineering, and service/release delivery.

PRE-REQUISITES

Foundational knowledge of programming and software design principles.

    Private Team Training Option

    This course can be delivered for groups of 5 or more and can be customized to meet the specific needs of your team. Fill out the form below and our Enterprise Solutions experts will contact you to discuss the best training solutions for your team.


    200

    DevOps Boot Camp, As Featured On

    training features

    • Award Winning DevOps Courseware

    • Featured on CNN, FOX News, MSNBC, Reuters

    • 98% Student Satisfaction Rate

    If you've ever considered working in DevOps, now might be a good time to pursue that option. Over the past few years, demand for IT professionals with experience in DevOps has skyrocketed. At the time of writing, a search for U.S. job postings that include the word "DevOps" turned up 5,733 jobs on Dice, 26,168 on Indeed.com and 65,727 on LinkedIn.

    • Audience

      Enterprise Architects, Solution Architects, Information Technology Architects, Senior Developers, and Team Leads

    • Pre-requisites

      Foundational knowledge of the software delivery problem domain. Some knowledge of executing Linux shell commands is recommended, but not mandatory.


    Chapter 1. Breaking Up Monoliths – Pros and Cons

    Traditional Monolithic Applications and Their Place
    Disadvantages of Monoliths
    Developer’s Woes
    Architecture Modernization
    Architecture Modernization Challenges
    Microservices Architecture is Not a Silver Bullet!
    What May Help?
    In-Class Discussion
    Summary

    Chapter 2. Microservice Development

    What are Microservices?
    Microservices vs Classic SOA
    Principles of Microservices Architecture Design
    Domain-Driven Design
    Domain-Driven Design – Benefits
    Microservices and Domain-Driven Design
    Designing for failure
    Microservices Architecture – Pros
    Microservices Architecture – Cons
    Docker and Microservices
    Microservice Deployment with Docker – Workflow
    Writing Dockerfile
    Kubernetes
    What is OpenShift
    OpenShift Architecture
    Microservices and Various Applications
    Web Applications
    Web Applications – Reference Architecture
    Web Applications – When to use?
    Single Page Applications
    Single Page Applications – Benefits
    Traditional Enterprise Application Architecture
    Sample Microservices Architecture
    Serverless & Event-driven Microservice – AWS Lambda
    Summary

    Chapter 3. Twelve-factor Applications

    Twelve-factor Applications
    Twelve Factors, Microservices, and App Modernization
    The Twelve Factors
    Categorizing the 12 Factors
    12-Factor Microservice Codebase
    12-Factor Microservice Dependencies
    12-Factor Microservice Config
    12-Factor Microservice Backing Services
    12-Factor Microservice Build, Release, Run
    12-Factor Microservice Processes
    12-Factor Microservice Port Binding
    12-Factor Microservice Concurrency
    12-Factor Microservice Disposability
    12-Factor Microservice Dev/Prod Parity
    12-Factor Microservice Logs
    12-Factor Microservice Admin Processes
    Kubernetes and the Twelve Factors – 1 Codebase
    Kubernetes and the Twelve Factors –
    2 Dependencies
    Kubernetes and the Twelve Factors – 3 Config
    Kubernetes and the Twelve Factors – 4 Backing Services
    Kubernetes and the Twelve Factors – 5 Build, Release, Run
    Kubernetes and the Twelve Factors – 6 Processes
    Kubernetes and the Twelve Factors – 7 Port Binding
    Kubernetes and the Twelve Factors – 8 Concurrency
    Kubernetes and the Twelve Factors – 9 Disposability
    Kubernetes and the Twelve Factors – 10 Dev/Prod Parity
    Kubernetes and the Twelve Factors – 11 Logs
    Kubernetes and the Twelve Factors – 12 Admin Processes
    Summary

    Chapter 4. REST Services

    Many Flavors of Services
    Understanding REST
    Principles of RESTful Services
    REST Example – Create
    REST Example – Retrieve
    REST Example – Update
    REST Example – Delete
    REST Example – Client Generated ID
    SOAP Equivalent Examples
    REST Example – JSON
    Famous RESTful Services
    Additional Resources
    What is gRPC?
    Protocol Buffers
    REST vs. gRPC
    Protobuf vs. JSONHTTP/2 vs. HTTP 1.1
    HTTP/2 vs. HTTP 1.1 (Contd.)
    Messages vs. Resources and Verbs
    Streaming vs. Request-Response
    Strong Typing vs. Serialization
    Web Browser Support
    REST vs. gRPC – In a Nutshell
    Summary

    Chapter 5. Microservices with Node.js

    What is Node.js?
    Node’s Value Proposition
    Example of a Node.js App: a Simple Web Server
    Node.js Project Types
    Managing Large Applications
    Core Modules
    Why Node.js uses JavaScript?
    The Traditional Concurrency Support Model
    Disadvantages of the Traditional Approach
    Event-Driven, Non-Blocking I/O
    The Success Callback Function
    Using Node Package Manager (NPM)
    NPM Registry (Repository)
    NPM Enterprise
    Package Life-Cycle Management
    Local and Global Package Installation Options
    Listing and Using Module Versions
    The Express Package
    Installing and Using Express
    Defining Routing Rules in Express
    Route Path
    The Response Object
    A Simple Web Service with Express ExampleThe MEAN Stack
    Summary

    Chapter 6. Introduction to Spring Boot for Non-Java Developers

    What is Spring Boot?
    Spring Boot Main Features
    Spring Boot vs DropWizard
    Spring Boot on the PaaS
    Understanding Java Annotations
    Spring MVC Annotations
    Example of Spring MVC-based RESTful Web Service
    Spring Booting Your RESTful Web Service
    Spring Boot Skeletal Application Example
    Converting a Spring Boot Application to a WAR File
    Summary

    Chapter 7. Spring REST Services

    Many Flavors of Services
    Understanding REST
    RESTful Services
    REST Resource Examples
    REST vs SOAP
    REST Services With Spring MVC
    Spring MVC @RequestMapping with REST
    Working With the Request Body and Response Body
    @RestController AnnotationImplementing JAX-RS Services and Spring
    JAX-RS Annotations
    Java Clients Using RestTemplate
    RestTemplate Methods
    Summary

    Chapter 8. Spring Security

    Securing Web Applications with Spring Security 3.0
    Spring Security 3.0
    Authentication and Authorization
    Programmatic v Declarative Security
    Getting Spring Security Gradle or Maven
    Spring Security Configuration
    Spring Security Configuration Example
    Authentication Manager
    Using Database User Authentication
    LDAP Authentication
    What is Security Assertion Markup Language (SAML)?
    What is a SAML Provider?
    Spring SAML2.0 Web SSO Authentication
    Setting Up an SSO Provider
    Adding SAML Dependencies to a Project
    Dealing with the State
    How Can I Maintain State?
    SAML vs. OAuth2
    OAuth2 Overview
    OAuth – Facebook Sample Flow
    OAuth Versions
    OAuth2 Components
    OAuth2 – End Points
    OAuth2 – Tokens
    OAuth – Grants
    Authenticating Against an OAuth2 API
    OAuth2 using Spring Boot – Dependencies
    OAuth2 using Spring Boot – application.yml
    OAuth2 using Spring Boot – Main Class
    OAuth2 using Spring Boot – SPA Client
    JSON Web Tokens
    JSON Web Token Architecture
    How JWT Works
    JWT Header
    JWT PayloadJWT Example Payload
    JWT Example Signature
    How JWT Tokens are Used
    Adding JWT to HTTP Header
    How The Server Makes Use of JWT TokensWhat are “Scopes”?
    JWT with Spring Boot – Dependencies
    JWT with Spring Boot – Main Class
    Summary

    Chapter 9. AWS Lambda

    What is AWS Lambda?
    Supported Languages
    Getting Your Code Up And Running in Lambda
    Examples of the Base Lambda Function
    Use Cases
    How It Works
    Example: Processing S3 Source Events with Lambda
    The Programming Model
    Configuring Lambda Functions
    Configure Triggers Page
    Lambda Function Blueprints
    How Do I Troubleshoot and Monitor My Lambda Functions?
    Developing Lambda in Java
    Summary

    Chapter 10. Consuming REST Services from a Client

    Accessing REST Services using jQuery – GET Example
    Accessing REST Services using jQuery – GET Example (Contd.)
    Accessing REST Services using jQuery – POST Example
    Accessing REST Services in React – Component
    Accessing REST Services in React – componentDidMount
    Accessing REST Services in React – render
    Accessing REST Services in React – POST Method
    The Angular HTTP Client
    Using The HTTP Client – Overview
    Importing HttpClientModule
    Simple Example
    Service Using HttpClient
    ES6 Import Statements
    Making a GET Request
    What does an Observable Object do?
    Using the Service in a Component
    The PeopleService Client Component
    Error Handling
    Making a POST Request
    Making a PUT Request
    Making a DELETE Request
    Summary
    Chapter 11. Docker Introduction
    What is Docker
    Where Can I Run Docker?
    Installing Docker Container Engine
    Docker Machine
    Docker and Containerization on Linux
    Linux Kernel Features: cgroups and namespaces
    The Docker-Linux Kernel Interfaces
    Docker Containers vs Traditional Virtualization
    Docker Integration
    Docker Services
    Docker Application Container Public Repository
    Competing Systems
    Docker Command Line
    Starting, Inspecting, and Stopping Docker Containers
    Docker Volume
    Dockerfile
    Docker Compose
    Using Docker Compose
    Dissecting docker-compose.yml
    Specifying services
    Dependencies between containers
    Injecting Environment Variables
    runC Overview
    runC Features
    Using runC
    Running a Container using runC
    Summary

    Chapter 12. Introduction to Kubernetes

    What is Kubernetes
    What is a Container
    Container – Uses
    Container – ProsContainer – Cons
    Composition of a Container
    Control Groups
    Namespaces
    Union Filesystems
    Popular Containerization Software
    Microservices
    Microservices and Containers / Clusters
    Microservices and Orchestration
    Microservices and Infrastructure-as-Code
    Kubernetes Container Networking
    Kubernetes Networking Options
    Kubernetes Networking – Balanced Design
    Summary

    Chapter 13. CI/CD with OpenShift, Jenkins, and Blue Ocean

    What is OpenShift
    OpenShift Online
    OpenShift Origin
    OpenShift Architecture
    OpenShift Origin Installation
    OpenShift CLI
    OpenShift CLI (Contd.)
    Jenkins Continuous Integration
    Jenkins Features
    Running Jenkins
    Downloading and Installing Jenkins
    Running Jenkins as a Stand-Alone Application
    Running Jenkins on an Application Server
    Installing Jenkins as a Windows Service
    Different types of Jenkins job
    Configuring Source Code Management(SCM)
    Working with Subversion
    Working with Subversion (cont’d)
    Working with Git
    Build Triggers
    Schedule Build Jobs
    Polling the SCM
    Maven Build Steps
    Jenkins / OpenShift Pipeline
    Jenkins / OpenShift Pipeline Output
    Installing Jenkins Plugins
    The Blue Ocean Plugin
    Blue Ocean Plugin Features
    New modern user experience
    Advanced Pipeline visualizations with built-in failure diagnosis
    Branch and Pull Request awareness
    Personalized View
    OpenShift Pipeline Output
    Creating OpenShift Blue Ocean Pipeline
    Summary

    Chapter 14. Leading Practices for Microservice Logging

    Logging Challenges
    Leading Practices
    Correlate Requests with a Unique ID
    Include a Unique ID in the Response
    Send Logs to a Central Location
    Structure Your Log Data
    Add Context to Every Record
    Examples of Content
    Write Logs to Local Storage
    Collecting Logs with Fluentd
    Leading Practices for Microservice Logging Summary
    Metrics Using Prometheus
    Overview
    Prometheus
    Prometheus Architecture
    Service Discovery
    File-based Service Discovery
    Istio and Prometheus
    Exposing Metrics in Services
    Querying in Prometheus
    Grafana
    Business Metrics
    Metrics Using Prometheus Summary
    Tracing Using Jaeger
    OpenTracing
    Jaeger
    Jaeger Architecture Diagram
    Jaeger Client Libraries
    Jaeger Sampling
    Jaeger Agent
    Jaeger Collector
    Query and Ingester Services
    Jaeger UI Example
    Jaeger and Prometheus
    Jaeger and Istio
    Tracing Using Jaeger
    Summary

    Chapter 15. Traffic Routing Patterns

    Edge Proxy Server
    Request Handling
    Filters
    Filter Architecture
    API Gateway for Routing Requests
    API Gateway for Routing Requests (Contd.)
    API Gateway – Example
    Rate Limiting
    Rate Limiting – Business Cases
    Configuring Rate Limiting in NGINX
    Circuit Breaker
    Design Principles
    Design Principles (continued)
    Cascading Failures
    Bulkhead Pattern
    Circuit Breaker Pattern
    Thread Pooling
    Request Caching
    Request Collapsing
    Fail-Fast
    Fallback
    Circuit Breaker Solutions
    Load Balancing in Microservices
    Server-side load balance
    Client-side Load Balance
    Architecture
    Service Mesh
    Service Mesh (Contd.)
    Service Mesh Solutions
    Content Delivery Network (CDN)
    How does a CDN Work?
    Benefits of using a CDN
    CDN Solutions
    Summary

    • Self-Paced Training

      Looking to learn at your pace?

      Learn More
    • PRIVATE GROUP TRAINING

      Find out more information about bringing an event to you.

      More Information
    • Special Offers

      Save with our current special offers

      Learn More