SHI Microservices Engineering Boot Camp Course User Guide

SHI Microservices Engineering Boot Camp Course

Product Information

The Microservices Engineering Boot Camp Course is a 3-day instructor-led training program designed to teach participants the practical toolset and skills required to work with microservices in their own systems. Whether you want to create new services, decouple existing services, or refactor a monolithic architecture, this course provides the knowledge and techniques to effectively implement microservice design patterns.
By adopting a microservices architecture, teams can achieve loosely coupled components and services, enabling them to deploy more freely and independently with reduced risk to the overall architecture.

Course Outline:

Part 1: Intro to Microservices

1. Optimize for speed, not efficiency
2. Case Study: General Electric
   • Throughput
   • Waste
3. Amazon Web Services Case Study (SOA/Microservices)
   • Problem: Scaling the Organization and the ‘Big ball of mud’
   • Conway’s Law
   • Service Oriented Architecture
   • Forced Self Service Mandate
   • Result: Amazon dominance of cloud
   • Result: High velocity at scale
4. Microservice challenge: Continuous Integration Service
   • On-Premise Jenkins
   • SaaS Service: Shippable, Jenkins, TravisCI
   • Exercise: Trigger build/tests from change

Part 2: Microservices in Development

1. Uber Case Study
   • 2000 services, 1000 engineers
   • Tradeoffs: Overall development speed
   • Cons: Technical challenges
2. Box Case Study
   • Traditional service deployment with bare metal
   • 10x faster workflow with DevOps practices
3. Microservice challenge: Image repository
   • Docker repository development instance
   • On-Premise Service: Quay by CoreOS
   • SaaS solution

Part 3: Microservices in Production

1. Spotify Case Study
   • 810 Services, 477 engineers
2. Microservice challenge: Service discovery
   • Skydns
   • Consul
   • Exercise: Resolve service with DNS
3. Security

Part 4: Putting it all together

1. Why Microservices?
   • Scale an organization
   • Tradeoffs
   • Fault Tolerance
   • Throughput
   • Waste
2. Kubernetes Alpha Features
   • Multi-Datacenter Control Plane
   • RBAC/Multi-tenancy
3. Openshift/Mesos/Other PaaS platforms
4. Exercise: Customize Microservice App
5. Exercise: Scale app for simulated demand
6. Review of Microservice Challenges
   • Secure Images
   • Highly available application
   • Secrets
   • Continuous Integration
   • DNS Name resolution
7. Summary

Product Usage Instructions

To make the most of the Microservices Engineering Boot Camp Course, follow these instructions:

1. Attend all sessions of the 3-day instructor-led course.
2. Participate actively in discussions and exercises during each session.
3. Take notes and ask questions to clarify any doubts or uncertainties.
4. Complete the exercises and challenges provided in each part of the course.
5. Make use of the practical toolset and skills taught in the course to implement microservices in your own systems.
6. Apply the concepts learned in real-world scenarios to optimize speed, decouple services, and refactor monolithic architectures.
7. Experiment with different technologies and platforms mentioned in the course, such as Jenkins, TravisCI, Docker, Kubernetes, Openshift, and Mesos.
8. Review the summary section to reinforce the key concepts and takeaways from the course.

By following these instructions, you will gain the necessary knowledge and skills to effectively work with microservices and enhance your system’s architecture.

About this course

For IT professionals, developers, software engineers, and DevOps practitioners – 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. The workshop includes 16 hands-on exercises that give you real-world practice on the engineering tools and skills a team needs in order to realistically implement your own flavor of Microservices architecture patterns so you can address the team needs of your own organization.
Whether you want to create new services, decouple a few services from your overall architecture, or refactor an entire monolithic architecture into a microservice design pattern, this course quickly teaches you the practical toolset and skills to get up and running with microservices in your own systems. Loosely coupled components and services allow teams to deploy more freely and independently, with less risk to the architecture

At course completion

After completing this course, students will be able to:

• Adopt, plan or improve your transition to microservices
• Map technical practices to the business strategy behind microservices
• Navigate different tools for enabling microservices and how to use them
• Communicate with stakeholders, management, and teams regarding needs and expectations around microservices
• Build microservices with Docker, Kubernetes, Jenkins, and JFrog
• Build more mature DevOps practices through microservice adoption
• Refactor monolithic systems into more modular, component-based systems
• Apply microservice use cases to continuous integration, delivery, and testing
• Enable more automated testing and self-service QA capability

Intro to Microservices

1. Optimize for speed, not efficiency

2. Case Study: General Electric

3. Throughput

4. Waste

5. Amazon Web Services Case Study (SOA/Microservices)

6. Problem: Scaling the Organization and the ‘Big ball of mud’

7. Conway’s Law

8. Service Oriented Architecture

9. Forced Self Service Mandate

10. Result: Amazon dominance of cloud

11. Result: High velocity at scale

12. Intro to Containers (encapsulation)

13. What is Docker

14. Exercise: Install Docker

15. Exercise: Docker Hello World

16. Docker ecosystem

17. Docker concepts

18. Container encapsulation/ideal use cases

19. Encapsulation

20. Speed

21. Increased utilization of computing resources

22. Benefits

23. Configure once, run everywhere

24. VM’s vs Container use cases

25. Databases & stateless workloads

26. Docker Architecture
    Exercise: Docker 101 – Web App
    Docker File System

27. Docker Images

28. Exercise: Stateless Web App

29. Local Registry

30. Data Volumes

31. Exercise: Docker 201 – Compose Multi-tier app

32. Continuous integration patterns

33. Docker Security

34. Continuous Integration

35. Canary Release

36. Blue Green Deployment

37. A/B Testing

38. Rolling Update

39. Jenkins Plugin

40. Microservice challenge: Continuous Integration Service

41. On-Premise

42. Jenkins

43. SaaS Service

44. Shippable

45. Jenkins

46. TravisCI

47. Exercise: Trigger build/tests from change

Microservices in Development

• Uber Case Study

  • 2000 services, 1000 engineers
  • Tradeoffs
  • Plus – overall development speed
  • Cons – technical challenges

• Box Case Study

  • Traditional service deployment with bare metal
  • 10x faster workflow with DevOps practices

• Microservice challenge: Image repository

  • Docker repository development instance
  • On-Premise Service
  • Quay by CoreOS
  • SaaS solution
  • Docker Hub
  • JFrog
  • Exercise: Submit an image to the service
    Exercise: Pull an image from the service

• Intro to Kubernetes (Containers at Google)

  • Prerequisites
  • Containers
  • Linux Kernel Features
  • Container User Experience
  • New Container Capabilities
  • Gaps using Containers in Production

• Exercise: Kubernetes 100: Hello World

• Core Concepts

  • Cluster Orchestration
  • Originated at Google
  • Open Source
  • Benefits
  • Design Principles

• Architecture

  • Master/Node
  • Kubectl
  • Replication Controller
  • Kubelet
  • Kube-Proxy
  • Persistent Volumes
  • Etcd
  • High Availability
  • Exercise: Kubernetes 101: Stateless web app

• Kubernetes Features

  • Pods
  • Labels
  • Services
  • Namespaces
  • Resource Quota

• Exercise: Kubernetes 201: Guestbook app

Microservices in Production

1. Spotify Case Study
2. 810 Services, 477 engineers
3. Microservice challenge: Service discovery
4. Skydns
5. Consul
6. Exercise: Resolve service with DNS
7. Security
8. Goals
9. Roles
10. Attribute-Based Access Control
11. Policies
12. Service Accounts
13. Secrets
14. Fourth Microservice challenge: Secrets
15. Vault
16. Kubernetes Secrets API
17. Exercise: Kubernetes – Store database credentials in the cluster
18. Cluster Add-ons
19. Cluster DNS
20. Logging with Elasticsearch and Fluentd
21. Container Level Monitoring
22. cAdvisor
23. InfluxDB
24. Prometheus
25. Exercise: WordPress on Kubernetes
26. Managing state with disposable architectures
27. Tradeoffs, standalone vs containerized databases
28. CAP Theorem
29. SQL Databases
30. NoSQL Databases
31. Exercise: Cassandra on Kubernetes
32. Practicing Failure
33. Optimize MTTR
34. Netflix Case Study
35. Simian Army
36. Graceful handling of failure

Putting it all together

1. Why Microservices?
2. Scale an organization
3. Tradeoffs
4. Fault Tolerance
5. Throughput
6. Waste
7. Kubernetes Alpha Features
8. Multi-Datacenter Control Plane
9. RBAC/Multi-tenancy
10. Openshift/Mesos/Other PaaS platforms
11. Exercise: Customize Microservice App
12. Exercise: Scale app for simulated demand
13. Review of Microservice Challenges
14. Secure Images
15. Highly available application
16. Secrets
17. Continuous Integration
18. DNS Name resolution
19. Summary

Read User Manual Online (PDF format)

Read User Manual Online (PDF format)  >>

Download This Manual (PDF format)

Download this manual  >>