(Micro?)services architecture in practice

(MICRO?) SERVICES
ARCHITECTURE IN PRACTICE

ADAM POLAK
HEAD OF NODE.JS
ADAM.POLAK@TSH.IO
POLAK.ADAM1

▸ SPECIALIZED SMALL APPS
▸ SEPARATE REPOS
▸ OWN STRUCTURE, API AND LANGUAGE
▸ INDEPENDENT BUILDS, TESTS AND DEPLOYS
▸ EASY TO MAINTAIN BECAUSE OF SMALL CODE
BASE
THEORY
(MICRO?) SERVICES ARCHITECTURE IN PRACTICE

▸ 5 SERVICES AT START
▸ SPA
▸ 6-7 DEVELOPERS AT START
PROJECT

▸ WHAT ABOUT REPOSITORIES?
▸ WHAT ABOUT API?
▸ WHAT ABOUT SETTING UP NEW SERVICE?
▸ WHAT ABOUT DEVELOPMENT?
▸ WHAT ABOUT TESTS?
▸ AND MANY MANY MORE
QUESTIONS?

SPA API
Frontend Backend
USE CASE #1

USE CASE SUMARY
▸ 2 “SERVICES” - SPA + API
▸ SEPARATE TEAMS
▸ DIFFERENT PROJECT STRUCTURE
▸ TECH PER PROJECT
▸ PRACTICES PER PROJECT

GATEWAY
PAYMENT
USE CASE #2 - BACKEND
REPORTINGSECURITYSEARCH

USE CASE #2 - FRONTEND
SPA GATEWAY

GATEWAY
NODE.JS
1 DEV
SECURITY
PHP
1 DEV
REPORTING
PHP
1 DEV
PAYMENT
.NET
1 DEV
SEARCH
PYTHON
1 DEV
SPA
REACT
1 DEV
THEORY

▸ BEST AVAILABLE TECH FOR GIVEN TASK
▸ ???
PROS

▸ 6 DIFFERENT TECH STACKS
▸ NO SHARED CODE = DUPLICATION
▸ 6 DIFFERENT BUILD/DEPLOY PROCESSES
▸ MUCH HARDER TO MOVE DEVS BETWEEN
PROJECTS
CONS

SPA
REALITY
SHARED
NODE.JS
CODE
SHARED
PHP
CODE
3 DEVS 2 DEVS 1 DEV
REACT
PHPNODE.JS
GATEWAYREPORTINGSEARCH SECURITYPAYMENT

▸ LOWER NUMBER OF TECHS = EASIER
MAINTANANCE
▸ SHARED CODE BETWEEN SAME TECH PROJECTS
▸ SHARED BUILD/DEPLOY PROCESS BETWEEN SAME
TECH
▸ SHARED STRUCTURE BETWEEN SAME TECH
PROJECTS
▸ YOU CAN MOVE FREELY BETWEEN PROJECTS OF
SAME TECH
PROS

▸ LOWER PERFORMANCE = WE CANNOT USE THE
BEST POSSIBLE TOOLS
▸ HARDER TO KEEP IT UP TO DATE
CONS

GATEWAY
REPORTING
SEARCH
SECURITY
PAYMENT
SPA
TSH REALITY = MONOREPO
3 DEVS 2 DEVS 1 DEVS
REACTPHPNODE.JS

▸ EASIEST TO DEVELOP
▸ STILL MODULAR
PROS
▸ LARGER CODE BASE
▸ HARDER TO KEEP BOUNDARIES
CONS

THE MOST BORING PART
OF A NEW SERVICE?

security
src
app
grpc
proto
service
container.ts
index.ts
SERVICE SETUP
SAME STRUCTURE
FOR EVERY
SERVICE
+
CUSTOM
MADE
OR
SERVICE
GENERATOR
= SECURITY
SERVICE

SETTING UP SERVICE AT TSH
tools create-service —project-name security
/services
/security
/src
/app
/grpc
/proto
/service
container.ts
index.ts

FOCUS ON BUSINESS LOGIC
NOT SERVICE STRUCTURE

▸ CLIENTS
▸ TYPES
▸ DTO’S
▸ COMMANDS / HANDLERS / ROUTES SKELETONS
THINGS GENERATED FROM CONTRACTS

GENERATING FROM PROTO AT TSH
syntax = "proto3";
import "messages/send-notification.proto";
import "messages/acknowledge-notification.proto";
import "messages/get-notifications.proto";
import "messages/get-notification.proto";
package notifications;
service NotificationsService {
rpc sendNotification (SendNotificationRequest) returns (SendNotificationResponse) {}
rpc acknowledgeNotification (AcknowledgeNotificationRequest) returns (AcknowledgeNotificationResponse) {}
rpc getNotifications (GetNotificationsRequest) returns (GetNotificationsResponse) {}
rpc getNotification (GetNotificationRequest) returns (GetNotificationResponse) {}
}

tools from-proto —service-name security --generator-type=client
/services
/security
/src
/grpc
/client
index.ts
/types
index.ts
index.ts
/proto
/service
service.ts
tools from-proto —service-name security --generator-type=service

/*****************************************/
/* THIS FILE WAS GENERATED */
/* DO NOT TOUCH */
/*****************************************/
import { Observable } from 'rxjs'
import * as grpc from 'grpc'
import { resolve } from 'path'
import { Logger, loadMessageDefinition, toPromise, toObservable } from 'brickvest-js-common'
import {
SendNotificationRequest,
SendNotificationResponse,
AcknowledgeNotificationRequest,
AcknowledgeNotificationResponse,
GetNotificationsRequest,
GetNotificationsResponse,
GetNotificationRequest,
GetNotificationResponse,
GetUnacknowledgedNotificationsCountRequest,
GetUnacknowledgedNotificationsCountResponse,
NotificationStreamToService,
NotificationStreamToClient,
} from '../types'
type ClientDependencies = {
uri: string
logger: Logger
}
class NotificationsClient {
private client: any
constructor(private dependencies: ClientDependencies) {
const messageDefinition = loadMessageDefinition(resolve(__dirname, '../../proto/notifications-service.proto'))
const proto: any = grpc.loadPackageDefinition(messageDefinition).notifications
this.client = new proto.NotificationsService(dependencies.uri, grpc.credentials.createInsecure())
}
public sendNotification(request: SendNotificationRequest): Promise<SendNotificationResponse> {
this.dependencies.logger.info(
`Notifications service client handling: sendNotification (${JSON.stringify(request)})`
)
return toPromise<SendNotificationRequest, SendNotificationResponse>(this.client, 'sendNotification')(request)
}
public acknowledgeNotification(request: AcknowledgeNotificationRequest): Promise<AcknowledgeNotificationResponse> {
`Notifications service client handling: acknowledgeNotification (${JSON.stringify(request)})`
)
return toPromise<AcknowledgeNotificationRequest, AcknowledgeNotificationResponse>(
this.client,
'acknowledgeNotification'
)(request)
}
public getNotifications(request: GetNotificationsRequest): Promise<GetNotificationsResponse> {
`Notifications service client handling: getNotifications (${JSON.stringify(request)})`
)
return toPromise<GetNotificationsRequest, GetNotificationsResponse>(this.client, 'getNotifications')(request)
}
public getNotification(request: GetNotificationRequest): Promise<GetNotificationResponse> {
this.dependencies.logger.info(`Notifications service client handling: getNotification (${JSON.stringify(request)})`)
return toPromise<GetNotificationRequest, GetNotificationResponse>(this.client, 'getNotification')(request)
}
public getUnacknowledgedNotificationsCount(
request: GetUnacknowledgedNotificationsCountRequest
): Promise<GetUnacknowledgedNotificationsCountResponse> {
`Notifications service client handling: getUnacknowledgedNotificationsCount (${JSON.stringify(request)})`
)
return toPromise<GetUnacknowledgedNotificationsCountRequest, GetUnacknowledgedNotificationsCountResponse>(
this.client,
'getUnacknowledgedNotificationsCount'
)(request)
}
public notificationsStream(request: NotificationStreamToService): Promise<Observable<NotificationStreamToClient>> {
`Notifications service client handling: notificationsStream (${JSON.stringify(request)})`
)
return toObservable<NotificationStreamToService, NotificationStreamToClient>(this.client, 'notificationsStream')(
request
)
}
}
export { NotificationsClient }

KEEP SAME CODE STYLE
AND USE STATIC ANALYSIS
TOOLS

(Micro?)services architecture in practice

DOCKERFILE
FROM node:10.13-alpine
ARG NPM_TOKEN
RUN echo “registry=https://private-repository.com/repository/npm/“ > /root/.npmrc;
RUN echo "always-auth=true" >> /root/.npmrc;
RUN echo "_auth=${NPM_TOKEN}" >> /root/.npmrc;
WORKDIR /dir
COPY . .
RUN npm conﬁg set unsafe-perm true
RUN apk add bash
RUN npm install ts-node ts-node-dev typescript -g
RUN npm i
EXPOSE 50050

DOCKER-COMPOSE
messaging:
image: our-app:latest
container_name: messaging
command: [bash, -c, 'ts-node-dev --poll ./services/messaging/src/index.ts’]
hostname:messaging
volumes: *volumes
depends_on:
- data
gateway:
container_name: gateway
command: [bash, -c, 'ts-node-dev --poll ./services/gateway/src/index.ts']
hostname: gateway
volumes: *volumes
depends_on:
- messaging

YAML ANCHORS AND REFERENCES TO KEEP IT CLEAN
js:
build:
context: .
dockerﬁle: docker/dev/Dockerﬁle
args:
- NPM_TOKEN
volumes: &volumes
- ./:/dir
- /dir/build/

TESTS AS DOCKER CONTAINER
integration-tests:
command:
[
'bash',
'-c',
‘./docker/wait.sh ldap-service 636 ./docker/wait.sh security 50050 npm run integration-tests',
]
volumes: *volumes
depends_on:
- messaging
- security
- ui-gateway

WHAT’S WRONG ON THIS PICTURE?
test('Gateway - workflow - create user test', { timeout: 10000 }, async (t: test.Test) => {
const clientSocket = await connectors.getConnector(config.clients.socketIO.type, config.clients.socketIO)
const validateMessage = createSocketValidator(clientSocket)
const connect$ = fromEvent(clientSocket, 'connect')
const mailerClientConfig = config.clients.mailerClient
const emailCountBeforeSending = await getCurrentEmailsCount(mailerClientConfig.mailHogUri)
connect$.subscribe(async () => {
(…)
t.end();
});
});

SOLUTION
test('Gateway - workflow - create user test', { timeout: 10000 }, async (t: test.Test) => {
const mailerClientConfig = config.clients.mailerClient
const emailCountBeforeSending = await getCurrentEmailsCount(mailerClientConfig.mailHogUri)
const clientSocket = await connectors.getConnector(config.clients.socketIO.type, config.clients.socketIO)
const validateMessage = createSocketValidator(clientSocket)
const connect$ = fromEvent(clientSocket, 'connect')
connect$.subscribe(async () => {
(…)
t.end();
});
});

YOU CAN CONTROL
SERVICES DIRECTLY
FROM TESTS

PASS DOCKER SOCKET TO CONTAINER
js:
build:
context: .
dockerﬁle: docker/dev/Dockerﬁle
args:
- NPM_TOKEN
volumes: &volumes
- ./:/dir
- /dir/build/
- /var/run/docker.sock:/var/run/docker.sock

CONTROL CONTAINERS FROM TESTS CONTAINER
test('Security integration tests - should reconnect to security service', async (t: test.Test) => {
pause(conﬁg.containers.security.name)
const payload = {…}
const authenticate = apiGatewayClient.proxy({
payload,
method: 'authenticate',
service: 'security'
})
const timedOut = await Promise.race([waitForTimeout, authenticate])
timedOut === true ? t.pass() : t.fail()
await ensureAreUpAndUnpaused([conﬁg.containers.security])
t.end()
})

CONTROL CONTAINERS FROM TESTS CONTAINER
export const ensureAreUpAndUnpaused = (containers: ContainerConﬁg[]): Promise<any> => {
const upOrUnpause: Array<Promise<any>> = []
containers.forEach(container => {
if (isPaused(container.name)) {
upOrUnpause.push(unpause(container))
} else if (isDown(container.name)) {
upOrUnpause.push(up(container))
}
})
return Promise.all(upOrUnpause)
}
export const pause = (containerName: string) => shell.exec(`docker pause ${containerName}`)

▸ MONOREPO IS EASIER TO DEVELOP WITH
▸ AUTOMATE PROJECT CREATION
▸ USE CONTRACTS AND GENERATE CODE FROM
THEM
▸ USE DOCKER
▸ FOCUS ON INTEGRATION TESTS
▸ TEST NEGATIVE PATHS
TL/DR

(Micro?)services architecture in practice

More Related Content

Similar to (Micro?)services architecture in practice (20)

More from The Software House (20)

Recently uploaded (20)

(Micro?)services architecture in practice