COURSE

Microservices Architecture with Jorge Ortiz‑Fuentes

Topics covered at MICRO-ARCH-JOF-03
View Schedule & Book More dates available

Next up:

Overview
Join Jorge Ortiz-Fuentes for this iOS Architecture Workshop

Passionate about distributed applications? Want to develop your knowledge of how to implement microservices using one of the preferred languages for that purpose?

This three-day virtual workshop follows an iterative and constructive path to build complex applications while keeping your code reusable, maintainable, testable and decoupled.

Learn the required theoretical concepts of key architectural topics and use realistic application examples to implement every feature using a step-by-step approach, and understand the principles that inform good architectural decisions, instead of using template implementations of solutions to problems.

This is a hands-on course, where you will write a full-fledged distributed application on your computer with the support and guidance of the instructor. You will also have access to the complete Go code in a Git repository to review parts of the course at your will.




Online Learning at Skills Matter

This course will be offered virtually over 3 full-day sessions.

Our virtual courses offer the same expert-led experience we've offered since 2013 — only now we’re making it accessible from the comfort of your own home (office).

You'll join Jorge and participants from around the globe in a virtual classroom where you'll utilise a variety of collaboration tools (e.g. Zoom, Slack, Notion.so) in this workshop-style course complete with interactive lectures, discussions and hands-on exercises.



Learn how to:

  • Write real-world distributed applications using an advanced architecture
  • Target common concerns like communications or resilience
  • Create more reusable and fully testable code
  • Improve collaboration within your team and take advantage of microservice teams
  • Decompose your domain into microservices
  • Create a Proof of Concept (PoC) without worrying about implementation details like the persistence method or how to communicate with other services
  • Iterate from the PoC to get the minimum viable product extending the application with different modules
  • Write independent microservices that communicate among them
  • Create code that is easier to run as a service implementing the 12 factor methodology
  • Implement an API Gateway and understand why is useful
  • Implement service descovery in your infrastructure
  • Choose the best communication mechanisms and implementing in your microservice
  • Apply this knowledge to your current codebase


About the Author

Jorge Ortiz‑Fuentes

Jorge is a freelancer dedicated to mobile development, security, and systems architecture. He started his work as a developer at M.I.T. in 1993 and since has collaborated in numerous software projects. Most of them were internally for HP where he worked for more than 15 years. Since 2008 he has been working in different aspects of mobile development. After playing with PalmOS, he learned Android programming for the first Google App contest and immediately started to play with the first iPhone SDK. He is an instructor in the best iOS and Android Bootcamps in the USA and Europe, and has spoken at some of the world's most renowned conferences about topics relating to mobile app architecture and best practices (and occasionally about Go and Raspberry Pis).

Programme


In this 3-day virtual workshop you'll learn the best practices of Microservices Architecture with experts Jorge Ortiz-Fuentes


Day 1

  • Architecture
    • Architecture is for you too: How a good architecture can help us solve the problems that we find when we write mobile apps
    • Using Design Patterns: A basic intro to design patterns and their value in writing good code
    • SOLID Principles: The five SOLID principles, their motivations, and how to apply them
    • (Micro)service architecture vs distributed architecture


  • Clean Architecture
    • Description and Pieces: The pieces that compose clean architecture and their purpose
    • The Dependency Rule: How to deal with dependencies properly in an architecture
    • Hints for Implementation: How to start creating an application that uses clean architecture


  • Decomposition
    • Define Microservice
    • Decomposition Strategies: Subdomains and Capabilities
    • Extract Minimum Viable Product: Plan the application we will write and how to approach the implementation of its features
    • First Design based on microservices
    • Real World strategies for extracting microservices


  • Initial Implementation of the 1st Microservice
    • Define package structure
    • Hardcoded response: Write code for the API that the "user" will interact with
    • Implement Domain Logic: Create the type that will contain the business logic of the first user story
    • Data (De)Serialization
    • Implement Persistence (Entity Gateway): The needs of persistence and how to implement them
    • Implement Routing (using Gorilla Mux and mentioning Gin and Chi
    • Connect the pieces with a command and make it all work: Write the glue code so all the pieces of the first user story work as expected

Day 2

  • 12 Factor Applications
    • Organize repositories
    • Implement dependencies with Go Modules
    • Add configuration options and use the environment
    • Backing Services: Implement the persistence with PostgreSQL and SQLx
    • Build, release, run: Define Docker images
    • Stateless Processes: Docker containers
    • Port Binding: Docker Compose and networks
    • Concurrency: Considerations
    • Disposability: Graceful shutdown and related tasks
    • Dev/Prod parity: Keeping them similar
    • Logs: The different logging levels microservce, containers, & full application
    • Admin Processes: Implementing database migrations

  • A Second Microservice
    • Serving Files
    • API Gateway


Day 3

  • Service Discovery
    • Self Registration
    • Client-side Discovery
    • The Docker and Kubernetes way

  • Sync Communications: Request/Response
    • REST Maturity Levels
    • Defining REST APIs with OpenAPI
    • Compression: Implementing trivial optimizations
    • Versioning REST APIs
    • Using gRPC instead: Use protobuffers and services
    • Versioning gRPC APIs
    • Circuit Breaker: Using Contexts and advantages of Hystrix


  • Async Communications: Publish/Subscribe
    • Messaging: Concepts and standards
    • Message Brokers vs Brokerless
    • Implement messaging


  • Async Communications: Async Request/Response
    • Improve Availability: Using the messaging system for asynchronous request/response


  • Data Consistency
    • Sagas: Problem with transactions and concept for a solution
    • Choreography Sagas
    • Orchestration-based Sagas

Audience

Audience

This course is intended for Go developers who would like to improve the way they build their distributed applications. Attendees should have at the very least 6 months of experience developing Go code (1 year preferred), know object-oriented programming and what a design pattern is.

Prerequisites

Attendees should have at the very least 6 months of experience developing Go applications (1 year preferred) and know object-oriented programming and what a design pattern is.