From DevOps to Platform Engineering: Master Backstage & IDPs

Develop a DevOps application from scratch, master pipelines and Docker images, and deploy to Kubernetes with Helm and Argo CD to build foundations for platform engineering.

Define a microservice deployment pipeline from a Python API to Kubernetes using GitHub, Docker, and a CI/CD workflow with Docker Hub, Helm, Argo CD, and GitHub actions.

Create and initialize a GitHub repository for a new application, clone it locally, install the git client if needed, and verify with git status and basic commands.

Install Docker on your computer and verify it by running docker ps and docker run hello world across Linux, Mac, Windows, and Ubuntu to prepare for Kubernetes on Docker.

Learn how to download and install Python and pip on any system, verify the installation with Python commands, and ensure pip is available for package management.

Choose a text editor and open the python app folder. Create a requirements.txt listing flask and install with pip install -r requirements.txt, pinning to 3.0.3.

Set up a Python Flask app with a source folder and app.py, and define two endpoints /api/v1/details and /api/v1/health for Kubernetes readiness and liveness probes.

Build a Flask API that returns a JSON hello world by using jsonify with a message key, then restart the server after code changes.

Build two Flask API routes: a health endpoint returning status and a details endpoint showing current time and hostname, using datetime and socket.gethostname in Python.

Create a Dockerfile to containerize the Python app, using a Python 3.1 alpine base, install dependencies from requirements.txt, copy the source, and run Python app.py.

Build a Docker image from the Dockerfile beside the source and requirements.txt, tag it as Python app v1, and view the 60 MB image before creating a container.

Launch a container from the built image with docker run, mapping port 5000 to 8080 on the host, then verify the health endpoint /api/v1/health.

learn how to use a docker registry with Docker Hub, create a repo for a Python app image, and generate a personal access token to authenticate and push images.

Log in to Docker Hub with your username and personal access token, tag your local image for your registry, and push it to the repository.

Install and configure kind to deploy a local Kubernetes cluster with Docker containers, then create the cluster and verify the control plane using docker ps.

Connect to the local cluster created by kind using kubectl; download and install the kubectl binary, set executable permissions, add it to your path, and run kubectl get pods.

Configure and deploy a Kubernetes ingress controller to expose applications externally, using nginx ingress, port mappings 80 and 443, and testing via localhost.

Build a deploy.yaml for the Python app from a Kubernetes deployment example, specify the image from Docker Hub and port 5000, then kubectl apply and verify with deployments and pods.

Create a Kubernetes cluster IP service with a service.yaml, using a deployment label selector and mapping container port 5000 to the service port, then kubectl apply and verify endpoints.

Learn to expose a Kubernetes app with an ingress by using a yaml example, apply it with kubectl, and verify routing on port 80 and the health endpoint.

Define the host for your ingress, apply kubectl changes to restrict hosts, and modify your Windows hosts file to map DNS to 127.0.0.1 for testing API v1.

Download and install helm according to the Linux installation guide, run the installation script, and set executable permissions to enable deploying applications with helm charts.

Learn to deploy a Python app to a Kubernetes cluster with Helm by creating a chart, configuring values.yaml, and tailoring deployment, service, and ingress templates.

Install a Helm chart by locating the directory with values.yaml, running Helm install with a release name and namespace, using --create-namespace, and verifying pods, ingresses, and services.

Deploy Argo CD on a Kubernetes cluster using helm, customize via a values file, configure ingress with TLS, and ensure secure HTTPS traffic with nginx annotations.

Learn how to log in to Argo CD by retrieving the initial admin secret from the Argo CD namespace, decoding the base64 password, and signing in with admin.

Push your local Python app, docker file, helm chart, and kubernetes manifests to GitHub by adding, committing, and pushing to main, using a personal access token for authentication.

Connect a GitHub repository to Argo CD via settings, paste the https URL, verify the repository connection, and prepare to deploy the Python app from the repo.

Deploy your Python app with Argo CD by selecting the main branch, specifying charts Python app, creating the namespace, and syncing for a healthy deployment.

Master GitOps by deleting applications in Argo CD, performing foreground deletion, and letting Argo CD remove pods, ingress, services, and all objects created by the application.

Configure a continuous integration pipeline with GitHub Actions to automatically rebuild and push Docker images on code changes, setting up a .github/workflows/ci.yaml workflow triggered by pushes to the main branch.

Configure a GitHub Actions workflow to build and push Docker images using Docker Hub secrets, then tag each build with the commit ID.

set dynamic docker tags in your CI pipeline by using the six-character commit ID from the main branch, triggered by GitHub Actions, and ensure workflow permissions.

Learn how to set dynamic Docker tags in a CI pipeline using GitHub Actions, including building, logging into Docker Hub, and pushing images with long and short commit sha tags.

Shorten the git commit id in a GitHub actions pipeline using a bash step, then reuse the shortened id to label and push a Docker image.

Deploy a continuous deployment pipeline by running GitHub actions on self-hosted Kubernetes runners, installing the controller, cert manager, and deploying via Helm or kubectl.

Define labels for your self-hosted runners to run jobs on online agents. Build on ubuntu latest GitHub runners while deployment uses your self-hosted runners, triggered by code changes.

Learn to deploy applications with Argo CD from GitHub actions by installing the Argo CD CLI, making it executable, and placing it in the system path to verify the version.

Enable continuous deployment with Argo CD by logging in via cli and syncing the app. Retrieve the admin password from Kubernetes secrets and login using the insecure option for ci.

Master continuous deployment by using the Argo CD CLI to list, inspect, and sync applications, triggering automated deployments from GitHub actions.

Construct a two-stage ci cd workflow in GitHub actions on self-hosted runners, securely log in to Argo CD with secrets, and perform app sync while debugging in-cluster dns access.

Build a robust CD workflow with GitHub Actions by integrating Argo CD endpoints, handling namespace-specific service access, and ensuring CI triggers CD via job dependencies.

Learn to build a CD workflow in GitHub Actions by using the needs keyword to connect CD to CI, then debug and push changes.

Install Argo CD in a Linux container and download the binary with curl. Build a GitHub Actions CD workflow, then perform app sync and verify the app after changes.

Learn how to pass the commit ID from one GitHub Actions job to another using outputs and needs, and update the values file tag to trigger Argo CD deployments.

Modify a values.yaml file programmatically with yq to update image tag in a kubernetes deployment, using pip to install yq inside a pod and applying the change via GitHub Actions.

Learn how to push changes to GitHub in a GitOps workflow using GitHub actions, including cloning the repo, committing updates, and triggering Argo CD sync, while debugging push permission issues.

Fix permission denied errors in GitHub actions by enabling read and write workflow permissions. Rerun the cd pipeline to sync Argo CD and deploy the updated image.

Explore Backstage to apply your DevOps knowledge within platform engineering, focusing on software catalog, tech docs, and software templates. Deploy on Kubernetes in production mode for your IDP.

Master Backstage installation by using Docker with a node 18 image, running npx to install Backstage, and mapping port 3000 with a Docker volume to a local app folder.

Deploy backstage with docker by installing, running yarn dev inside a node container, then expose it by binding to all interfaces (host: 0.0.0.0) via app config.yaml listen settings.

Configure GitHub OAuth authentication for backstage by creating a GitHub OAuth application, setting the home page and callback to port 7007, and saving the client ID and secret.

Configure GitHub OAuth by adding the client ID and secret to app config files, update local YAML with the changes, and set environment variables when launching the container.

Configure backstage with environment variables for the GitHub provider, then download and install the GitHub authentication plugin. Update the app config to include auth provider and proceed to frontend setup.

Add the GitHub login plugin to the backstage front end by updating imports and components, configuring the GitHub provider, and modifying front end and back end files for sign in.

Configure backstage resolvers to enforce a GitHub user whitelist by creating a users.yaml in the catalog, then reference it in the app config to enable login.

Configure and test GitHub authentication for Backstage by setting up OAuth app, wiring credentials and environment variables, installing the plugin, updating resolvers and whitelist, then run server and sign in.

Learn to register existing components as services in the backstage software catalog using catalog-info.yaml, including GitHub repo links and an owner.

Create and register a development group in Backstage by defining a groups.yaml team, adding the user as a member, and updating the config to enable group creation.

Push the catalog-info file to GitHub, pull updates, then copy the component URL into Backstage and click analyze to register the component.

Enable backstage to register existing components into the catalog by updating the app config and yaml rules, then analyze, import, and view owners, lifecycle, and source code.

Configure backstage tech docs by adding a docs folder with index.md, writing markdown documentation for your Python app, and enabling backstage to render it as HTML.

Explore turning markdown into HTML with Mkdocs and integrate it into Backstage using the tech docs plugin, including configuring Mkdocs, creating docs/index.md, and annotating catalog-info.

Install and configure backstage tech docs with Mkdocs, verify the plugin presence, and enable local generation inside the backstage docker container via app.config.local.

Install and configure TechDocs in Backstage to render GitHub-hosted markdown documentation as HTML, using mkdocs and a development in-memory database.

Explore software templates in backstage to quickly spin up new projects and standardize your organization's best practices, like Dockerfile, GitHub actions, and Kubernetes, with a single click.

Showcases building a software template from creation to deployment, yielding a new component with a GitHub repo, documentation, and CI/CD enabled at a single click.

Explore Backstage software templates, define steps, and use actions to deploy apps with inputs, and install and configure Backstage actions including the publish GitHub action and built-in actions.

Install and configure the backstage GitHub plugin to enable GitHub interaction from backstage, start the server with yarn dev, and dispatch GitHub actions.

Connect Backstage to GitHub by configuring the GitHub integration, generating a token with repo and workflow permissions, and wiring it to Backstage via environment variables to manage repos and workflows.

Create a new, dedicated backstage software templates repo separate from the Python app repo, starting with a Python template and planning future Go, Java, and NodeJS templates.

Learn to build a Backstage template by writing a YAML file, similar to a GitHub Actions workflow. Define metadata and parameters: component ID and environment with values dev and prod.

Configure backstage to load templates from a GitHub URL, define input parameters with dev or prod environments, and validate names before generation.

Explore three steps to automate templates: render a template with input parameters, publish the rendered files to a GitHub repository, and register the new component in Backstage.

Learn to render a template, create and push a new GitHub repo, and register the component in Backstage using a catalog-info.yaml file.

Push changes to GitHub to load the latest catalog info and software template, restart Backstage, render the Python application template, and publish the new Python app repo.

Turn your DevOps project into a Backstage software template by migrating code into the template folder, defining a template YAML with render steps, and replacing hardcoded values with user inputs.

Leverage backstage templates and GitHub Actions to rename files by user-provided app name, manage branches, and deploy with environment values while ensuring the app exists before Argo CD sync.

Rename the charts directory to reflect the user's app name and create two values files, dev and prod, configuring environment-specific replicas and argo cd deployments via ingress.

Rewrite your DevOps project as backstage templates by updating env and app name in the source, configuring ingress via the charts values file, and committing changes to GitHub.

Start the backstage server, render the template from the Python app YAML, and generate a tailored GitHub repo with dev or prod settings, GitHub Actions CI/CD, and Argo application sync.

Deploy a backstage app by building a Docker image, pushing to Docker Hub, and configuring a GitHub Actions workflow; centralize secrets with a GitHub organization for shared reuse.

Centralize secrets in GitHub, enable inheritance across repos, add Docker Hub token and username, decode Argo CD password from base64, and reconfigure backstage to build and push to Docker Hub.

Configure backstage to create repositories under your organization, update the owner, restart the server, and use organization secrets for CI in actions, with runners reconfigured for the new organization.

Configure distributed builds on GitHub orgs by converting self-hosted runners to the organization level, linking kubernetes runners, updating tokens and admin permissions, and enabling all repos with proper workflow permissions.

Configure a GitHub organization, ensure new repos from a software template are public via Backstage, and run actions with self-hosted runners, validating Docker Hub builds in the cd pipeline.

Diagnose and fix backstage template rendering issues by escaping variables in templates, validating commit value propagation in GitHub actions, and restarting backstage to ensure CI/CD and Argo CD steps run.

Explore troubleshooting Argo CD sync failures by ensuring the target app exists before syncing, create the app via GitHub Actions, and verify Kubernetes namespaces and permissions.

Automate linking GitHub repos to Argo CD using Backstage templates, employing the Argo CD CLI to connect, login, list, and add repositories, and only create when not already present.

Automate Argo CD app management with backstage templates by checking for existing apps, creating them via CLI, and wiring repo, charts path, and dev or prod values.

Automate Argo CD operations with Backstage templates by adding a wait step, configuring app wait, and changing the policy from auto to manual, demonstrated through a dev workflow.

Clean up Backstage templates, set manual Argo CD sync, and remove old apps and repos; then fix tech docs by building a Docker image with Python.

Explore testing a fully functional Backstage software template by deploying a Python app, inspecting the GitHub repo, docker image, and tech docs, and monitoring the CI/CD pipeline with Argo CD.

Customize the Backstage cicd view by installing the GitHub Actions plugin, configuring authentication providers, annotating catalog info with organization slug, and updating Backstage with Docker and frontend setup.

Import and configure a backstage plugin to customize the ci cd view. Update the service entity page to include GitHub actions content and view runs for your repository.

Deploy backstage in production by creating a Postgres database container on a backstage network, configuring db name and user credentials via environment variables, and testing with Docker before Kubernetes.

Create a production ready backstage docker setup by building the backend outside Docker and copying the build into a host image, with a production config using Postgres.

Build the back end per the documentation, edit the production config.yaml and App.config, and disable guest authentication and the Kubernetes plugin for production.

Configure the production Postgres settings and disable the guest and Kubernetes plugins, then build the backstage backend with appconfig YAML and production config, verify dist bundle, and prepare the dockerfile.

Create a production-ready dockerfile for backstage by using a node 18 base, installing python tools, removing sqlite in favor of postgres, copying catalog and production YAML, and building the image.

Learn to build a production-ready backstage docker image by updating the docker file with mkdocs and venv setup, managing dockerignore, and resolving common build errors.

deploy backstage with postgres as docker containers, using production image, network setup, and logs to verify; resolve login identity issues and access localhost:7007.

Configure and run Backstage in Docker with Postgres, fix resolvers and user YAML paths, and ensure persistence by storing registrations in the database across container restarts.

Deploy backstage on Kubernetes with the official Postgres helm chart, then customize a values file to set global Postgres auth, username, and database, and enable persistence.

Deploy a Backstage database on Kubernetes with helm by preparing a values file, adding the Bitnami repo, and deploying Postgres in the backstage namespace, then verify connectivity with psql.

Write Kubernetes manifests to deploy backstage, including a deployment, service, and ingress, or use a Helm chart; configure environment variables for the Postgres host, user, and password.

Build and customize a Backstage v1 Docker image, configure environment variables for the GitHub token and the Postgres host, then tag, log in, and push the image to Docker Hub.

Deploy backstage to a Kubernetes cluster with a backstage YAML, verify pods and ingress, and troubleshoot certificate issues by updating https settings and the GitHub OAuth app.

Align the backstage production url with the oauth url on kubernetes. Override app config base URLs for backend and frontend using environment variables, then redeploy and verify login.

Master devops led deployment of Python apps with docker, CI/CD, and Kubernetes via YAML, Helm, and Argo CD, and explore backstage concepts like software catalog, templates, and production deployment.