top of page

How to protect your Microservices?

Microservices - also known as the microservice architecture - is an architectural style that structures an application as a collection of services that are

  • Highly maintainable and testable

  • Loosely coupled

  • Independently deployable

  • Organized around business capabilities

  • Owned by a small team

The microservice architecture enables the rapid, frequent and reliable delivery of large, complex applications. It also enables an organization to evolve its technology stack.

Security challenges associated with Microservices

Microservices are usually widely distributed systems with complex access rules, more traffic to monitor, and a larger attack surface. Additionally, most of the microservices cloud run on cloud environments, which also have varying security configurations and controls.

Due to the large number of APIs, ports, and components that are exposed, traditional firewalls may not provide adequate security. These issues make microservices deployments more vulnerable to various cyber threats like the man-in the middle, injection attacks, cross-site scripting, DDoS, and others.

Network security is another challenge with microservices. In particular, the identity and access control assume a new level of complexity. Other vulnerabilities include insecure code and flaws in the service discovery systems.

Although securing microservices are harder than monolithic applications, you can protect them effectively by establishing a good strategy and following the best practices.

Ideally, the architecture requires a distributed approach that should cover all the different components.

Typical areas to address include

  • Protecting applications, microservices, and users

  • Securing Identity and Access Management

  • Protecting data

  • Enhance service-to-service communication security

  • Monitoring the microservices and security systems

Best practices for securing Microservices

One of the best strategies is to use a combination of best practices, tools, and controls to protect the entire ecosystem. The actual approach may differ according to the type of services, applications, users, environmental and other factors.

If you decide to use microservices, you need to ensure that you are meeting all the security demands for the services, connections, and data.

Let us now have a look at some effective microservices security practices.

1. Build security from the start

Make security part of the development cycle. Ideally, integrate security into the microservices development and deployment right from the start. Addressing security this way is an easy, effective, and cheaper approach than waiting to add it when the software development is nearing completion.

2. Use Defense in Depth Mechanism

The Defense in Depth (DiP) is a technique where you apply several security layers on your services and data. The practice makes it harder for attackers to penetrate through the multiple layers hence providing strong security for your services and data.

Unlike the perimeter security solutions such as the firewalls, the Defense-in-depth concept is different. It relies on a combination of tools such as antivirus, firewall, patch management, anti-spam software, and others to provide multiple security layers distributed throughout the system.

Defense-in-depth multi-layer security

With this approach, you must first identify the sensitive services, after which you apply the appropriate security layers around them.

3. Deploy security at container level

Most often, microservices rely on container technology. As such, securing the containers, both internally and externally, is one way of reducing the attack surface and the risks. Ideally, aiming at the least privilege security principle is a good practice and requires a combination of strategies including but not limited to;

  • Limiting permission to the minimum required

  • Avoid running services and anything else using the sudo or privileged accounts.

  • Limit or control the access and consumption of available resources. For example, limiting access to the operating system resources by the containers helps to prevent data theft or compromise.

  • Do not store secrets on the container disk.

  • Use appropriate rules to isolate access to the resources.

It is also vital to ensure that container images do not have any vulnerabilities or security issues. A regular security and vulnerability scanning of the containers will help to identify risks.

Typical image scanning tools include Clair, Anchore, and more.

4. Deploy a Multi-Factor authentication

Enabling multi-factor authentication enhances the security of the front-end.

Users accessing will need to provide their username and password details in addition to another form of verification, such a code sent to their phones or a specified email address. The technique makes it harder for attackers, who may be using stolen or hacked credentials, to access the microservices since they won’t have a way to provide the second authentication.

5. Use User Identity and Access tokens

In microservices deployment, a large number of applications and services will require secure authorization and access control. An authorization framework such as the OAuth 2.0 and OpenID enables you to process the tokens securely, hence protect your microservices. Consequently, this allows third-party applications to access other services or data from users.

In a typical deployment, the main application will prompt the user to authorize the third party service. Upon accepting this, the application generates an access token for the session.

In particular, OAuth is one of the most effective strategies for user identity and access control. Although there are several other authorization protocols, and you can also build your own, it is best practice to use the OAuth since is more standard, stable, and widely accepted.

6. Create an API Gateway

Generally, the microservices consist of several components distributed over different networks and accessible from a wide range of systems and clients. Exposing the microservices increases vulnerabilities and security risks. One way to protect them is to create a single and secure entry point that helps you to centralize all access from external systems and clients.

To achieve this, deploy an API gateway to screen all incoming requests for security issues before routing them to the appropriate microservices. The API gateway sits between the client applications and the microservices. It then limits exposing the microservices while providing additional request management functions such as authentication, SSL termination, protocol translation, monitoring, request routing, caching, and more.

With this approach, the API gateway routes all the external services to the microservices while also supporting the defense-in-depth security principle.

Microservices API gateway Image Livebook

7. Profile APIs based on the deployment zone

Implement role-based restrictions by ensuring that the users only have access to the APIs and services they require. Since most malicious software often exposes a service to more people, limiting access to only authorized users reduces the risks. One technique of reducing the exposure is to label the APIs based on the users who should have access to them. Generally, the APIs can be;

  • Ethernet APIs – For services exposed to the external world outside the data center.

  • Corporate Zone APIs – these are meant for the internal private traffic

  • DMZ APIs– to handle the traffic the originates from the internet

  • Hybrid Zone APIs – for data centers deployments

8. Secure the service-to-service communications

Effective practices involve authenticating and authorizing requests when two microservices are communicating.

Generally, there are three main techniques that you can use to secure the interservice communications. These are the Trust the network, JSON Web Token (JWT), and Mutual Transport Layer Security (mTLS, or Mutual TLS).

Securing inter-service communications with JWT

Out of the three, the most popular is the mTLS. In this approach, each microservice must carry a public/private key pair. The client microservice then uses the key-pair to authenticate itself to the receiving microservice through the mTLS.

During authentication, each microservice generates a certificate. Afterward, each microservice will use the certificate from the other to authenticate itself.

While TLS provides integrity and confidentiality for the data in transit, it also enables the client to identify a microservice. The client microservice usually knows the other microservice. However, since TLS is one-way, a receiving microservice cannot verify the client microservice, – and attackers can exploit this flaw. On the other hand, the mTLS provides a means in which each of the microservices can identify the other.

9. Rate limit client traffic

Limiting the external traffic prevent issues such as denial of service (DoS) attacks as well as instances where some clients consume most of the application bandwidth. One approach is to apply various rules that can monitor and control the rate of traffic sent or received from a client based on the IP, time, etc.

Configure your services to slow down if they detect several failed login attempts to your APIs or any other suspicious activity.

A slow system would discourage the attackers and probably give up their attempt to access the services. You can rate limit using the API gateway, through the code, or any other technique. Usually, most of the SaaS environments have API rate limiting to minimize abuse by users as well as attacks.

10. Use orchestration managers

The orchestrations managers allow you to automate the configuration, coordination, and other microservices management tasks in addition to enhancing security. Usually, the tools enable you to manage multiple containers, limit metadata access, segregate workloads, collect logs, and more.

Some orchestration tools have additional features that enable the developers to store and share sensitive information such as the SSL certificates, encryption keys, passwords, and identity tokens.

The two commonly used methods for effective microservice orchestration are;

  • Coding the orchestration as a microservice

  • Using the API gateways to provide an orchestration layer

Orchestration through the API gateway is not recommended due to challenges when there is a need to scale services.

11. Monitor all your systems and services

Since microservices rely on distributed systems, you need to have a reliable and effective monitoring strategy for all the individual components.

Deploying continuous monitoring allows you to detect and address security risks in good time. Towards this, there is a wide range of microservices monitoring solutions, including Prometheus, Statsd, InfluxDB, Logstash, etc.

Monitoring inside the microservices architecture

Use the appropriate tools to monitor internal systems and services. Some best practices include;

  • Enable logging at the application layer. You can Splunk, Graphana, ELK stack, and other tools that collect logs at the application, container, network, and infrastructure levels.

  • Monitor the usage metrics

  • Use the trends in metrics such as CPU, memory, response times, errors, notifications, and others to detect unusual activities indicative of an existing or potential attack.

  • Audit the logs in areas such as incoming client requests, database records, containers, and others to identify inconsistencies or unusual activities.

12. Automate security activities

Automate security processes such as deploying updates, vulnerability scanning, monitoring, enforcing policies, and other activities. Additionally, check the updates to ensure that they are secure and that they are not introducing new vulnerabilities.

After updates, the security software should ideally perform tests on all containers and microservices to see if there could have been some vulnerabilities or security issues that happened before.

13. Protect data at all times

Protect data in transit and at rest. Ideally, enforce the use of HTTPS for all communications, to secure the data in transit, and encryption for all sensitive data at rest. Avoid transmitting and storing plain text passwords, keys, credentials, and sensitive data that resides outside the code.

Resource: geekflare

The Tech Platform



bottom of page