Internal developer portal

Top 10 tools for Site Reliability Engineers: ensuring production readiness and meeting standards

June 5, 2024

Netta Borowitsh
Netta Borowitsh
Top 10 tools for Site Reliability Engineers: ensuring production readiness and meeting standards
Example H2

Ready to start?

Intro

Site Reliability Engineers (SREs) play a crucial role in maintaining the reliability, performance, and scalability of production systems. To achieve these goals, Site Reliability Engineers  rely on a variety of tools that fall into several categories, including monitoring/observability, on-call and incident management, and configuration and automation. Here, we discuss ten essential Site Reliability Engineer tools, including both open-source options and commercial solutions.

{{cta-demo}}

‍Monitoring/Observability Tools

1. Prometheus

Credit: metricfire https://www.metricfire.com/blog/what-is-prometheus/

Prometheus is an open-source systems monitoring and alerting toolkit originally built at SoundCloud. Since its inception, Prometheus has grown to be an integral part of the monitoring stack for many organizations.

Prometheus provides a powerful data model and query language (PromQL), allowing SREs to gain insights into system performance and reliability. It’s highly flexible and can be integrated with various exporters to collect metrics from different systems.

2. Grafana

Credit: Grafana https://grafana.com/grafana/

Grafana is an open-source platform for monitoring and observability. It allows you to query, visualize, and understand your metrics no matter where they are stored. Grafana can be integrated with Prometheus, Elasticsearch, InfluxDB, and many other data sources.

Grafana’s powerful visualization capabilities make it an indispensable tool for SREs. It enables the creation of dashboards that provide real-time insights into system health and performance.

3. Datadog

Credit: krakend https://www.krakend.io/docs/telemetry/datadog/

Datadog is a commercial monitoring and analytics platform for cloud-scale applications. It integrates with various services and tools, providing comprehensive visibility into the performance of applications and infrastructure.

Datadog offers features such as APM (Application Performance Monitoring), log management, and security monitoring, making it a versatile tool for SREs to ensure production readiness.

On-Call and Incident Management Tools

4. PagerDuty

Credit: PagerDuty https://www.pagerduty.com/blog/pagerduty-introduces-team-organization-feature/v

‍

PagerDuty is a commercial incident management platform that helps SREs manage and resolve incidents faster. It provides on-call scheduling, alerting, and escalation policies, ensuring that critical issues are addressed promptly.

PagerDuty’s integration with various monitoring tools allows for seamless incident detection and resolution, improving overall system reliability.

Configuration and Automation Tools

5. Jenkins

Using Jenkins agents
Credit: https://www.jenkins.io/doc/book/using/using-agents/

Jenkins is an open-source automation server that supports building, deploying, and automating any project. It is a widely used tool in continuous integration and continuous delivery (CI/CD) pipelines.

For SREs, Jenkins provides the ability to automate routine tasks and ensure that code changes are consistently and reliably tested and deployed.

6. Ansible

Credit: https://www.softwareadvice.co.nz/software/183001/ansible-automation-platform

‍

Ansible is an open-source automation tool used for configuration management, application deployment, and task automation. It simplifies complex orchestration and configuration tasks.

Ansible's agentless architecture and easy-to-learn syntax make it a favorite among SREs for maintaining consistent environments and automating repetitive tasks.

7. Terraform

Credit: https://coralogix.com/blog/terraform-quick-start-tutorial/

‍

Terraform is an open-source infrastructure as code (IaC) tool that allows you to define and provision data center infrastructure using a declarative configuration language.

Terraform's ability to manage infrastructure lifecycle, versioning, and modularity helps SREs automate the provisioning and management of infrastructure, ensuring consistency and reliability.

Internal Developer Portals

8. Port's Internal Developer Portal

‍

Port's Internal Developer Portal provides a centralized hub for managing all aspects of software delivery and infrastructure. This tool helps SREs ensure production readiness by offering features such as service cataloging, deployment tracking, and automated compliance checks.

Port’s portal enhances collaboration between development and operations teams, ensuring that all standards are met and production environments are well-managed.

‍

Additional essential tools

9. Nagios

Credit: https://www.nagios.com/solutions/operating-system-monitoring/

‍

Nagios is an open-source monitoring system that provides monitoring and alerting services for servers, switches, applications, and services. It helps SREs ensure that their infrastructure and applications are running smoothly.

Nagios offers a comprehensive suite of monitoring capabilities, including event handling, reporting, and an extensive plugin library, making it a versatile tool for maintaining system health.

10. New Relic

‍

Credit: https://docs.newrelic.com/docs/tutorial-improve-site-performance/improve-website-performance/

New Relic is a commercial observability platform that provides real-time insights into application performance and infrastructure. It offers APM, infrastructure monitoring, and synthetic monitoring to help SREs ensure production readiness.

New Relic's comprehensive monitoring capabilities and intuitive interface make it a valuable tool for identifying and resolving performance issues quickly.

Conclusion

These 10 tools for site reliability engineers, categorized into monitoring/observability, on-call and incident management, configuration and automation, and internal developer portals, provide SREs with the necessary capabilities to ensure production readiness and maintain high standards. By leveraging these tools, SREs can effectively monitor, automate, and manage their systems, ensuring that they meet the demands of modern infrastructure and application environments.

Previous article

Next article

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start
{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start
{{cta-demo-baner}}

Book a demo right now to check out Port's developer portal yourself

{{port-for-backstage}}

Apply to join the Beta for Port's new Backstage plugin

Apply for beta
{{jenkins}}

It's a Trap - Jenkins as Self service UI

Read more
{{gitops}}

How do GitOps affect developer experience?

Read more
{{ebook}}

It's a Trap - Jenkins as Self service UI. Click her to download the eBook

Download eBook
{{cyberark}}

Learning from CyberArk - building an internal developer platform in-house

Read more
{{cta-demo}}
{{reading-box-backstage-vs-port}}

Further reading:

Read: What are the technical disadvantages of Backstage?

Compare: Backstage vs. Port

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

You may also be interested in

Building the perfect internal developer platform

Building the perfect internal developer platform

Read more
How to use JQ commands to speed developer workflows

How to use JQ commands to speed developer workflows

Read more
Debugging K8s with K8sGPT in your internal developer portal

Debugging K8s with K8sGPT in your internal developer portal

Read more

Starting with Port is simple, fast and free.

Let’s start