Microservices Boot Camp (Extended Edition)

Course Objectives

Throughout the course, students will explore the fundamentals of microservices, learning how to practical scenarios that will arise in microservices development.  Working within the microservices architecture, students will gain hands-on experience using Docker and Kubernetes to transform microservices use case to an Internet-scale deployment.  Students will also examine the relationship between microservices and DevOps and the microservices development life cycle. The course addresses additional challenges such as scaling, monitoring, securing, and containerizing microservices.

Working in an engaging, hands-on learning, led by our experienced services professional, students will be able to:

·        Explain the issues associated large, monolithic applications and how microservices present an opportunity to address many of those issues.

·        Adopt, plan or improve your transition to microservices

·        Map technical practices to the business strategy behind microservices

·        Recognize and use best practices relative to designing and working with microservices

·        Navigate different tools for enabling microservices and how to use them

·        Communicate with stakeholders, management, and teams regarding needs and expectations around microservices

·        Get deep-dive, hands-on practice with Docker and Kubernetes tools for core microservices architecture

·        Get hands-on practice with the toolchain in our real-world application labs

·        Work with implemented microservices to package, deploy, and manage them.

·        Understand and work with the Cloud to scale microservices

·        Build more mature DevOps practices through microservice adoption

·        Understand how to refactor monolithic systems into more modular, component-based systems

·        Apply microservice use cases to continuous integration, delivery

Course Prerequisites

This introductory and beyond-level course explores the terminology, specification, tools, processes and technologies specific to microservices. It is geared for attendees who need to understand, manage and / or implement existing or upcoming microservice projects. In order to gain the most from this course, students currently be working in the IT industry.  Basic knowledge of Java programming syntax (used in some of the services labs) is helpful.

Related Training: We offer other courses in this training suite:

• TT7050  Understanding Microservices | A Technical Overview – 1 day
• TT7053 Microservices Engineering Boot Camp  – 3 days – subset of the 5 day Camp
• TT7055  Microservices Implementation Boot Camp – 5 days; superset of the 3-day camp with deeper dive topics
• TT7345 Working with Java Microservices – 3 days (for developers)
• And many other services, container, API, DevOps and programming courses – please inquire for details and complete catalog.

Course Agenda

1. Demystifying Microservices

• The evolution of microservices
• What are microservices?
• Characteristics of microservices
• Microservices examples
• Microservices benefits
• Relationship with other architecture styles
• Microservice use cases

2. Applying Microservices Concepts

• Patterns and common design decisions
• Microservices challenges
• The microservices capability model

3. Microservices Evolution

• Reviewing the microservices capability model
• Understanding the PSS application
• Death of the monolith
• Microservices to the rescue
• The business case
• Plan the evolution
• Target architecture

4. Docker

• Docker 30,000ft overview
• Our training environment
• Installing Docker
• Our first containers
• Background containers
• Restarting and attaching to containers

5. Understanding the Docker Model

• Understanding Docker images
• Building images interactively
• Building Docker images with a Dockerfile
• CMD and ENTRYPOINT
• Copying files during the build
• Multi-stage builds
• Publishing images to the Docker Hub
• Tips for efficient Dockerfiles

6. The Container Network Model

• Naming and inspecting containers
• Container networking basics
• Container network drivers
• The Container Network Model
• Service discovery with containers
• Ambassadors

7. The Docker Development Life Cycle

• Local development workflow with Docker
• Working with volumes
• Compose for development stacks
• Advanced Dockerfiles
• Tying it all together with CI/CD and continuous integration patterns

8. The Microservices Development Life Cycle

• Our sample application
• Kubernetes concepts
• First contact with kubectl
• Running our first containers on Kubernetes
• Accessing logs from the CLI
• Declarative vs imperative

9. The Kubernetes Network Model

• Kubernetes network model
• Exposing containers
• Shipping images with a registry
• Running our application on Kubernetes
• Deploying with YAML

10. Setting Up Kubernetes

• Setting up Kubernetes
• The Kubernetes dashboard
• Security implications of kubectl apply
• Scaling our demo app
• Daemon sets
• Labels and selectors
• Authoring YAML

11. Microservices Healthchecks

• Rolling updates
• Healthchecks
• Recording deployment actions

12. Namespaces and kubectl proxy

• Namespaces
• Accessing the API with kubectl proxy
• Controlling a Kubernetes cluster remotely
• Accessing internal services

13. Exposing Microservices with Ingress

• Exposing HTTP services with Ingress resources
• Kustomize
• Managing stacks with Helm
• Creating Helm charts

14. The Microservices Security Model

• Network policies
• Authentication and authorization
• Pod Security Policies
• The CSR API
• OpenID Connect
• Securing the control plane

15. Volumes and Microservices

• Volumes
• Building images with the Docker Engine
• Building images with Kaniko

16. Stateful Microservices

• Managing configuration
• Stateful sets
• Running a Consul cluster
• Local Persistent Volumes
• Highly available Persistent Volumes

17. The Microservices Logging and Metrics Model

• Centralized logging
• Collecting metrics with Prometheus
• Resource Limits
• Defining min, max, and default resources
• Namespace quotas
• Limiting resources in practice
• Checking pod and node resource usage
• Cluster sizing
• The Horizontal Pod Autoscaler

18. Extending Microservices APIs

• Extending the Kubernetes API
• Operators
• Owners and dependents

19. The Microservices Cluster

• Building our own cluster
• Adding nodes to the cluster
• The Container Network Interface
• Interconnecting clusters
• API server availability
• Static pods
• Upgrading clusters
• Backing up clusters
• The Cloud Controller Manager
• Git-based workflows

20. Putting it all Together

• DevOps
• Developing Microservices
• Microservices, DevOps, and cloud
• Practice points for microservices development
• More real-world use cases and case studies

Course Materials

Each student will receive a Student Guide with course notes, code samples, software tutorials, diagrams and related reference materials and links (as applicable). Our courses also include step by step hands-on lab instructions and and solutions, clearly illustrated for users to complete hands-on work in class, and to revisit to review or refresh skills at any time. Students will also receive the project files (or code, if applicable) and solutions required for the hands-on work.