Beyond Portals: Designing a Robust Development Platform with Backstage

Introduction

Backstage has emerged as a powerful open-source platform for building developer portals. However, its potential extends far beyond just serving as a portal. By integrating Backstage with various tools and services, you can transform it into a comprehensive development platform that manages deployments, environments, and runtime operations. This tutorial will guide you through extending Backstage to create a cohesive execution layer that streamlines development workflows.

Prerequisites

Before diving into the tutorial, ensure you have the following:

• A working Backstage instance
• Basic knowledge of Kubernetes, Docker, and CI/CD concepts
• Access to a Kubernetes cluster
• Familiarity with Terraform and Docker Compose

Step 1: Setting Up Backstage

If you haven't already set up Backstage, start by creating a new Backstage app:

npx @backstage/create-app

Follow the prompts to set up your Backstage application. Once done, navigate to the app directory and start the server:

cd my-backstage-app
yarn dev

Your Backstage instance should now be running at http://localhost:3000.

Step 2: Integrating Kubernetes

To manage deployments and environments, integrate Kubernetes with Backstage. Start by adding the Kubernetes plugin:

yarn add @backstage/plugin-kubernetes

Next, configure the Kubernetes plugin in your Backstage app. Edit app-config.yaml to include Kubernetes cluster details:

kubernetes:
  serviceLocatorMethod:
    type: 'multiTenant'
  clusterLocatorMethods:
    - type: 'config'
      clusters:
        - url: 'https://<your-cluster-url>'
          name: 'my-cluster'
          authProvider: 'serviceAccount'

Ensure that your Backstage instance has the necessary permissions to access the Kubernetes API.

Step 3: Adding CI/CD Capabilities

To streamline deployments, integrate a CI/CD tool like Jenkins or GitHub Actions. For this tutorial, we'll use GitHub Actions.

First, create a GitHub Actions workflow file in your repository:

name: CI/CD

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '14'
    - run: yarn install
    - run: yarn build

  deploy:
    runs-on: ubuntu-latest
    needs: build

    steps:
    - name: Deploy to Kubernetes
      uses: actions/deploy-to-kubernetes@v1
      with:
        kubeconfig: ${{ secrets.KUBECONFIG }}
        manifests: ./k8s/

Ensure your Kubernetes credentials are stored securely in GitHub Secrets.

Step 4: Creating a Runtime Operations Dashboard

Backstage can be extended with custom plugins to create a runtime operations dashboard. Start by generating a new plugin:

yarn backstage-cli create-plugin

Follow the prompts to create a plugin named runtime-ops. Implement the plugin to interact with your Kubernetes cluster, displaying real-time metrics and logs.

Example code for fetching pod logs:

import { KubernetesClient } from '@backstage/plugin-kubernetes';

async function fetchPodLogs(namespace: string, podName: string): Promise<string> {
  const client = new KubernetesClient();
  const logs = await client.getPodLogs(namespace, podName);
  return logs;
}

Integrate this functionality into your plugin's UI to display logs and metrics.

Step 5: Automating Infrastructure with Terraform

To manage infrastructure as code, use Terraform. Start by defining your infrastructure in a main.tf file:

provider "kubernetes" {
  config_path = "~/.kube/config"
}

resource "kubernetes_namespace" "example" {
  metadata {
    name = "example-namespace"
  }
}

resource "kubernetes_deployment" "example" {
  metadata {
    name = "example-deployment"
    namespace = kubernetes_namespace.example.metadata[0].name
  }

  spec {
    replicas = 3

    template {
      metadata {
        labels = {
          app = "example"
        }
      }

      spec {
        container {
          image = "nginx:1.14.2"
          name  = "example"
        }
      }
    }
  }
}

Run terraform init and terraform apply to provision your infrastructure.

Operational Checklist

• Ensure Backstage is running and accessible
• Kubernetes plugin configured and tested
• CI/CD pipeline set up and verified
• Runtime operations dashboard implemented
• Infrastructure defined and managed with Terraform

By following these steps, you can extend Backstage beyond a developer portal to a robust development platform that enhances your team's productivity and operational efficiency.