Understanding SLIs and SLOs in Microservices Architecture with PowerShell Commands and Code Observability
Tags: webdev, microsoftgraph, softwaredevelopment, devops
Published: 2024-07-12 06:26:18

Performance and dependability of applications have become critical constrains to modern software developers. To achieve these goals various concepts including Service Level Indicators (SLIs) and Service Level Objectives (SLOs), microservices, PowerShell commands and [code observability](https://stackify.com/what-is-observability-everything-a-beginner-needs-to-know/) play pivotal role. This article gives a detailed explanation of the above concepts to help the developers and IT specialists to deepen their knowledge and utilization.

**[What is SLI and SLO](https://stackify.com/slo-vs-sla/)?**

Service Level Indicators (SLIs)
Resulting SLIs are measures that express the performance and availability of a service from the client’s point of view. Such signs are useful to determine to what extent a given service is efficient and whether it works as per the expectations. Typical SLIs are time to respond, failure rate, uptimes, and transactions per unit of time. 

Example SLIs: 

- 
Response Time: It is the time which is required for the system to respond to any request from the user. 

- 
Error Rate: The fraction of the number of failed requests out of all the requests. 

- 
Availability: The proportion of total working time, when the terminal is available for serving clients. 

- 
Throughput: The amount of times per some time interval that the service has been requested. 


Service Level Objectives (SLOs)
SLIs are Service Level Indicators and SLOs are the specific and measurable objectives set on them. They are used to determine the appropriate quality and dependability of a service. Communication of SLOs is important to ensure service quality as well as to ensure that the expectations of the service providers and the users are met. 

Example SLOs: 

- 
Response Time SLO: As for the interactions that occurred at Abercrombie and Fitch, 95% of it should be answered within 200 milliseconds. 

- 
Error Rate SLO: There are general rules for the sizes of these samples, as well as for the error rate that should not be more than 0. 5% of total requests. 

- 
Availability SLO: The service should be available 99 percent of the time available to be used at the consumer’s disposable 24 7. 9% of the time. 

- 
Throughput SLO: It should have the capability to process at least one thousand requests in a minute. 

## Microservices Architecture
What is Microservices Architecture?

[Microservices architecture](https://stackify.com/what-are-microservices/) is an architectural pattern that organizes an application by a group of smaller, light-weight services that are not tightly coupled and therefore can be deployed independently. Every service aligns with a unique business capability, and the function interfaces with other services via APIs. 
 
**Benefits of Microservices Architecture **
 
Scalability: Microservices can be sized independently, they can be provisioned to manage load and the demand conservatively and efficiently. 
 
Flexibility: The various services can be developed using different technologies and frameworks increasing versatility as well as creativity . 
 
Resilience: If one microservice fails, then the other microservices and the overall system are not impacted which improves system reliability. 
 
Faster Development: When all these services are structured into teams, multiple services can be developed and deployed at a go which is efficient. 
 

## Challenges of Microservices Architecture 
 
Complexity: When there are several services, one has to manage and coordinate them which complicates the system. 
 
Inter-Service Communication: Coordination of communication between services can prove rather difficult for an organization to achieve. 
 
Data Consistency: Therefore, data consistency when implementing the services entails planning and implementation. 
 
Monitoring and Debugging: There is more monitoring and analyzing problems in a distributed system contrasting with those in monolithic systems.

## PowerShell Commands for Managing Microservices

PowerShell is a scripting language and a framework used in remote management of software applications such as microservices as well as their environment. Here are some essential [PowerShell commands](https://stackify.com/powershell-commands-every-developer-should-know/) for common tasks:Here are some essential PowerShell commands for common tasks: 
 
Starting and Stopping Services 
 
# Start a microservice 
 
Start-Service -Name "MicroserviceName" 
 
# Stop a microservice 
 
Stop-Service -Name "MicroserviceName" 
 
 
# Restart a microservice 
 
Restart-Service -Name "MicroserviceName" 
 
Checking Service Status 
 
# Get the status of a specific microservice 
 
Get-Service -Name "MicroserviceName" 
 
## Get full description of a microservice 
 
All the related services, Get-Service -Name “MicroserviceName” | Format-List * 

## Managing Docker Containers
 
Microservices typically execute in Docker. Here are some PowerShell commands for managing Docker containers:Here are some PowerShell commands for managing Docker containers: 
 
## List all Docker containers 
 
docker ps -a 
 
># Run a Docker Container 
 
docker start <container_id> 
 
># Pause a Docker container 
 
docker stop <container_id> 
 
># Re-start a Docker container 
 
docker restart <container_id> 
 
The command # remove a Docker container refers to deleting a Docker container. 
 
docker rm <container_id> 

## Deploying Microservices
 
The creation and deployment of microservices can be scripted through PowerShell scripts. Here is an example script to deploy a microservice:Here is an example script to deploy a microservice: 
 
# Define variables 
 
$repository = "my-docker-repo" 
 
$imageName = "my-microservice" 
 
$tag = "latest" 
 
$containerName = "my-microservice-container" 
 
$port = 8080 
 
># Pull the latest Docker image 
 
docker pull $repository/$imageName:$tag 
 
First, halt and eliminate the current container. 
 
docker stop $containerName 
 
docker rm $containerName 
 
Run a new container # 
 
docker run -d -p $port:80 –name ${container_name} ${repository}/${image_name}:${tag} 
 
## Code Observability
What is Code Observability? 
 
Code observability is a form of designing and embedding monitoring into code with the aim of getting information on its usage and enactment. It is a process of gathering logs, metrics and traces to know about the working of application in real time. 
 
**Importance of Code Observability **
 

- 
Enhanced Debugging: Observability assists in making the diagnosis of problems within the code faster and therefore solves the problem of diagnostics.  

- 
Performance Monitoring: This makes it possible to always keep a check and balance on the parameters of application performance, which should meet with the stated SLOs. 
 
- 
Proactive Issue Resolution: Observability helps in ahead-of-time consideration and neutralization of possible problems before they become a problem to the users. 
 
- 
Improved Reliability: Thus, the actions of teams [with access to user and crash logs] can be used to identify defects, so as to increase the application’s reliability and fault tolerance. 
 
**Implementing Code Observability **

- 
Logging: It is recommended to utilize the structured logging to log dynamic data about events that occur in the application. Utilize tools of log aggregation to analyze the logs through the aid of elasticsearch and kibana. 
Example: 

console. log(JSON. stringify({ level: Calling the messageInfo model with the following parameters: type: ‘info’, message:’User login successful’, userId: user. id 

- 
Metrics: Measurable data that may include the response time, error rate, level of utilization of resources among others should be gathered and used. To the metrics, Prometheus and Grafana can be used to help in monitoring. 
Example: 

const client = require('prom-client'); 
 
const httpRequestDuration = new client. Histogram({ 
 
name: 'http_request_duration_seconds', 
 
help: It is the time taken for the HTTP requests in seconds. 
 
labelNames: ['method', 'route', 'status_code'], 
 
}); 

- 
Tracing: Previously, tracing was a centralized process; however, in microservices architecture, tracing should be done through the distributed tracing mechanism. Implement tracing tools such as, OpenTelemetry, and Jaeger to enable the visualization of the distributed traces. 

Example: 
import { NodeTracerProvider } from ‘@opentelemetry/node’; 
 
const { SimpleSpanProcessor } = require('@opentelemetry/tracing’); 
 
import { ConsoleSpanExporter } from ‘@opentelemetry/tracing’; 
 
const provider = new NodeTracerProvider(); 
 
provider. addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter())); 
 
provider. register(); 

- 
Alerting: It is to establish alerts for communicating to the team about any deviations or cross- thresholds. Mobile app for real time notification, and for subsequent app reminders you can set up alerting tools such as PagerDuty or Slack. 
Example: 

One example for alert management is Prometheus Alertmanager. 
 
alert: HighErrorRate 
 
expr: job:request_errors:rate5m{job="my-microservice"} > 0. 05 
 
for: 5m 
 
labels: 
 
severity: page 
 
annotations: 
 
summary: ‘’High error rate observed in my-microservice’’. 
 
description: These are some findings of the Audio Transcription Metrics Monitor, such as ‘Error rate greater than 5% for last 5 min’. 

## To sum up
SLIs and SLOs, microservices architecture, PowerShell commands, code observability are the items, which reflect the need for modern software development. Thus, the development and operations teams are able to guarantee that new-field-specific applications are efficient, dependable, and easy to support. 

Companies and Government use SLIs and SLOs to set exact goals on performance and reliability to ensure that subordinates deliver high-quality service. Microservices architecture has some advantages in the form of scalability, flexibility, and fault tolerance but comes with the cost of the system’s complexity and coordination effort. Commands in PowerShell help in handling microservices and its requisites whereas the observability in code helps to detect, debug, and optimize the applications. 

Each of these practices can be assimilated into the development process to create sound applications that participate in fulfilling end-user expectation and organizational goals.