Webservices en Service Oriented Architecture

Lesmethode :

Klassikaal

Algemeen :

Het opzetten van een moderne, flexibele bedrijfsarchitectuur vraagt vaak om services als de spil voor een soepele integratie tussen diverse applicaties. Echter, het willekeurig inzetten van services kan verleidelijk zijn, ook wanneer het niet de optimale keuze is. Deze cursus biedt daarom eerst een overzicht van de voordelen én nadelen van services, en helpt je te begrijpen wanneer hun gebruik gerechtvaardigd is.

We verdiepen ons in verschillende servicetypes, waaronder web services, microservices, en functies als services, en lichten toe in welke scenario's elk type waardevol is. Daarnaast bespreken we implementatiemethoden zoals SOAP en WSDL, en verkennen we de voordelen van nieuwere technologieën zoals REST, gRPC, en GraphQL. Ook belichten we het ontwerp van diensten via event-driven architecture, om de flexibiliteit en loskoppeling van systemen te bevorderen.

Een effectieve service moet directe waarde voor de business leveren. Daarom benadrukken we het belang van het afstemmen van de functionaliteiten van je services op de businessbehoeften. Ook behandelen we welk detailniveau van servicegegevens ideaal is en welke patronen je kunt toepassen voor een efficiënte servicearchitectuur.

Met aandacht voor CQRS, choreografie, SAGA's, het CAP-theorema, en meer, wordt je volledig bijgespijkerd over de staat van de techniek.

In de cursus bieden we hands-on ervaring met services door middel van demo's, waarbij geen programmeerervaring nodig is. Dit maakt het leren toegankelijk en praktisch, gericht op het begrijpen en toepassen van services in de moderne bedrijfsarchitectuur.

Doel :

Na het afronden van de cursus:

Heb je inzicht in het gebruik van de verschillende services.
Begrijp je de voordelen van een services architectuur.
Weet je hoe je applicaties kunt automatiseren en loskoppelen t.b.v. een meer flexibele architectuur.
Heb je inzicht in de migratiemogelijkheden van legacy applicaties naar een flexibele service aanpak.
Begrijp je dat services onmisbaar zijn voor een Agile organisatie en ben je uitstekend voorbereid om de digitale transformatie binnen jouw bedrijf vorm te geven.

Doelgroep :

Software architecten, designers, ontwikkelaars en iedereen die gebruik wil maken van de mogelijkheden van Web Service technologie.

Voorkennis :

Het cursusmateriaal is in het Engels. Een goede beheersing van de Engelse taal is vereist.
Enige kennis van object georiënteerde concepten is een pre.

Onderwerpen :

- What are services?
   - Service types: webservices, microservices, FAAS
   - 'Small' and focused
   - Loosely coupled
   - Language-neutral
   - Bounded context
   - Domain-driven design
   - Comparing service vs monolithic architectures
- Benefits from services
   - Enterprise solutions context
   - Challenges with monolithic architecture
   - Developer perspective
   - Tester perspective
   - Business owner perspective
   - Service management perspective
   - Exercise: SOAP and REST service
- Analysing and designing services
   - What is a service-based application?
   - Scaling through decomposition
   - Key principles
   - Who uses microservices?
   - Domain-driven design
   - Service analysis, design and implementation
   - Exercise: analyse course case study and use domain driven design
- Contract management
   - WSDL, Swagger or OpenAPI?
   - API economy in numbers
   - API-led architecture
   - The API gateway
   - Agents or micro gateways
   - Using the Sidecar pattern
   - Exercise: write a WSDL, an OpenAPI or a Swagger contract
- Service case studies
   - (Micro)services at Robinhood
   - Migrating the monolith at Uber
   - Netflix and NoOps
   - The contents of an event
   - Exposing services to the world
   - Exercise: building a simple service
- Architecture of a (micro)services application
   - Role of the architect
   - A microservice platform
   - services layer
   - communication
   - Locating services
   - The application boundary
   - Client layer
   - Exercise: Hands-on with a services registry
- Architectural modularity
   - Technical drivers
   - Business drivers
   - How much modularity is enough?
   - Sacrificial architecture
   - Demo: micro frontend
- Service design
   - Hexagonal service design Pattern
   - Central business logic and adapters
   - Service taxonomy
   - Identifying taxonomy
- Service granularity
   - Purpose and Service Scope
   - Using a boundary layer for abstraction
   - The BFF pattern (backend for frontend)
   - Fine-grained versus coarse-grained approach
   - Workflow and choreography issues
   - Code structure and reuse
   - Demo: configuring an API gateway
- Share nothing architecture
   - Bounded contexts
   - Shared libraries
   - The monorepository pattern
   - Sharing a database and schema
- Inter-service communication
   - RMI and RPC drawbacks
   - Using gRPC between services
   - How gRPC works
   - Load balancing gRPC servers
   - Exercise: API gateway as load balancer
- Orchestration and choreography
   - Defining Orchestration
   - Defining choreography
   - Service Orchestration
   - Issues with gateway orchestration
   - Using service orchestrators
   - Orchestration and loose coupling
   - Exercise: walk through a saga definition
- Service aggregation
   - aggregation vs orchestration
   - Issues with orchestration
   - Using service aggregation
   - aggregation use cases
   - Minimizing dependencies
- Deploying microservices
   - Why is deployment important?
   - A service production environment
   - Serverless computing
   - Building service artefacts
   - Securing the services
   - Service to host models
   - Containerizing a service
   - Deploying to a cluster
   - Deploying services without downtime
   - Exercise: deploy a service to a container
- Transactions and queries with microservices
   - Consistent transactions
   - Event-based communication
   - Sagas
   - CQRS
   - Event Sourcing
   - CAP theorem
   - Exercise: testing the CQRS pattern
- services and distributed data
   - Change control Issues
   - Connection Issues
   - Bounded context and data
   - Exercise: using polyglot persistence
- distributed data issues
   - Data sharing and choreography
   - Data sharing and Data Replication
   - Sharing data between services
   - Using replicated caching
   - Limitations and restrictions
- designing reliable services
   - Defining reliable Service
   - What could go wrong
   - designing reliable communication
   - Maximizing service reliability
   - Rely on a service mesh?
   - Exercise: using Kubernetes
- DevOps and services
   - When to use DevOps
   - Defining DevOps
   - DevOps for fast deployments
   - Organizing teams to support services
- Using an event broker
   - Building topologies
   - Event-driven Approach
   - Processing events with stateful functions
   - Making events the source of truth
   - Demo: Using an event broker
- Service governance
   - Centralized versus decentralized governance
   - Enterprise transformation with services
   - Advice on patterns and templates
   - Advice on tools
   - Monitoring and observability of services
- Testing services
   - Testing strategies and unit testing
   - Writing integration tests
   - Developing component tests
   - Writing end-to-end tests
   - Demo: A look at testing approaches