IBM DevOps and Software Engineering

Teams cannot ship what they cannot coordinate. You follow the software lifecycle, then use Git and GitHub for history, branching, pull requests and review so many people can change one codebase safely.

• The software development lifecycle
• Requirements and design at a basic level
• Git commits, branches and merges
• Branching strategies for teams
• Pull requests and code review
• Issues and project boards on GitHub

You build A repository using a branching strategy with reviewed pull requests.

Servers run Linux, and operations work happens at the command line. You move around the file system, manage permissions, chain commands, and write shell scripts that automate repeated tasks.

• Navigating the file system and managing files
• Users, groups and permissions
• Pipes, redirection and text tools
• Processes and services
• Shell variables, conditions and loops
• Writing and scheduling a script

You build A shell script that automates a routine task and runs on a schedule.

Python covers the work between shell scripts and full applications. You write functions, work with files and JSON, and call REST APIs, which is the base for both automation and web services.

• Types, control flow and functions
• Working with files and JSON
• Modules and libraries
• Calling REST APIs
• Handling errors in scripts
• Packaging a script for others to run

You build A Python tool that calls an API and writes a report.

A small web service is the thing most pipelines end up delivering. You build an AI-backed service in Flask, test it, and deploy it to a server so there is something real to automate.

• Routes and responses in Flask
• Calling an AI service from a route
• Configuration and environment variables
• Running behind a production server
• Deploying to a web server
• Checking that the service is healthy

You build A Flask service deployed to a server with a health endpoint.

Containers make software run the same everywhere. You build Docker images, run them on Kubernetes, and manage deployments, scaling and updates on OpenShift.

• Writing a Dockerfile and building images
• Registries and tagging
• Pods, deployments and services
• Configuration and secrets in a cluster
• Scaling and rolling updates
• Working with OpenShift

You build The Flask service packaged as an image and running on a cluster.

Delivery gets easier when services are small and independent. You split an application into services, route traffic between them with a service mesh, and run suitable work as serverless functions.

• Designing small, independent services
• Service communication and APIs
• A service mesh and what Istio provides
• Serverless functions and event triggers
• Observing traffic between services
• Operational costs of many services

You build A two-service application with traffic managed through a mesh.

Automation is only as good as the tests it runs. You write unit tests first, drive design from them, describe behavior in readable scenarios, and use mocks to isolate what you are testing.

• Unit tests and what makes a good one
• Red, green, refactor
• Fixtures and mocks
• Code coverage and its limits
• Behavior-driven scenarios in plain language
• Running tests automatically

You build A test suite written before the code, plus behavior scenarios for one feature.

A pipeline turns a commit into a running release without hand-offs. You build pipelines in Jenkins and OpenShift Pipelines, deliver with Argo CD, and provision infrastructure with Terraform.

• Pipeline stages: build, test, package, deploy
• Jenkins pipelines as code
• Pipelines on OpenShift
• GitOps and delivery with Argo CD
• Infrastructure as code with Terraform
• Deployment strategies and rollback

You build A pipeline that builds, tests and deploys the service after each commit.

Speed without security ships vulnerabilities faster. You study the OWASP risks, write code that avoids them, manage secrets and dependencies, and build security checks into the pipeline.

• The OWASP risks and how they arise
• Input validation and injection
• Authentication and session handling
• Managing secrets and configuration
• Scanning dependencies and images
• Security checks inside the pipeline

You build A security review of the service with fixes and an automated scan in the pipeline.

Shipping is only half the loop. You collect logs, metrics and traces from running systems, use OpenTelemetry and Instana, and set alerts that tell you about a problem before users do.

• Logs, metrics and traces
• Instrumenting an application with OpenTelemetry
• Dashboards that answer real questions
• Alerting without alarm fatigue
• Service level indicators and objectives
• Investigating an incident from the data

You build A monitoring dashboard and alert rules for the deployed service.

Build an application from several services, deploy it with containers and serverless functions, test it, and wire a pipeline around it. The project shows the whole delivery loop working on your own code.

• Designing the services
• Writing tests and the behavior scenarios
• Containerizing and deploying
• Building the delivery pipeline
• Adding monitoring and a security scan

You build A multi-service application with tests, a delivery pipeline and monitoring.