Table of Contents
Overview
PART VI focuses on how Linux fits into modern software delivery: development workflows, DevOps practices, automation, configuration management, and cloud infrastructure.
Earlier parts of the course showed how to use and administer Linux systems. This part assumes you can already install, configure, and troubleshoot a Linux machine, and builds on that to:
- Develop and debug software effectively on Linux
- Automate builds, tests, and deployments (CI/CD)
- Manage configuration of many servers as code
- Define and provision infrastructure using declarative tools
- Run and operate Linux in major public clouds
You’ll see Linux not just as “an operating system”, but as the foundation of automated, scalable, and reproducible environments.
Learning Goals of This Part
By the end of PART VI, you should be comfortable with:
- Using Linux as a primary development environment:
- Building, testing, and debugging software
- Working with version control (especially Git)
- Automating builds and basic toolchains
- Applying DevOps principles on Linux:
- Understanding what CI/CD is and how pipelines run on Linux
- Reading and writing simple YAML-based pipeline definitions
- Using common hosted CI solutions (GitHub Actions, GitLab CI)
- Managing fleets of Linux systems:
- Describing system configuration with tools like Ansible, Puppet, Chef
- Running repeatable playbooks or manifests to keep systems consistent
- Treating infrastructure as code (IaC):
- Describing cloud resources (VMs, networks, storage) in Terraform
- Versioning and reviewing infrastructure changes
- Applying and destroying infrastructure safely
- Operating Linux in cloud environments:
- Understanding how Linux instances differ between AWS, Azure, and GCP
- Using basic cloud networking and security constructs
- Monitoring and scaling Linux-based applications in the cloud
How This Part Is Structured
This part is divided into five chapters, each with a specific focus:
- Linux for Developers
- How compilers, build tools, debuggers, and Git fit into a Linux-based development workflow.
- You’ll see Linux as a productive environment for writing and building software.
- DevOps on Linux
- How DevOps practices (especially CI/CD) are implemented on Linux runners and servers.
- You’ll write and interpret simple pipeline configurations and understand how they integrate with your code repositories.
- Configuration Management
- How to describe server configuration in reusable files and apply those descriptions across many Linux machines.
- Focus is on concepts shared by popular tools and the specific workflows of Ansible, Puppet, and Chef.
- Infrastructure as Code
- How to model and control infrastructure (instances, networks, databases, etc.) using declarative code.
- You’ll learn the Terraform basics needed to provision and manage resources in a repeatable way.
- Cloud Computing with Linux
- How Linux operates inside public cloud providers.
- The practical realities of launching, networking, securing, and monitoring Linux systems in AWS, Azure, and GCP.
Each chapter introduces only what is needed to understand its specific tools and workflows; detailed system administration topics are left to earlier parts of the course.
How This Part Builds on Earlier Parts
To get the most from PART VI, you should already be comfortable with:
- Basic Linux command line usage:
- Navigating directories, editing files, using
ssh - Essential system administration:
- Managing packages, services, users, and permissions
- Basic networking and security concepts:
- IP addresses, ports, firewall basics, SSH keys
Here, those skills become building blocks:
- You’ll use shell skills to write build scripts, test commands, and deployment steps.
- You’ll rely on package management and service control when writing configuration management playbooks or manifests.
- You’ll apply networking and security fundamentals when configuring cloud VMs, security groups, and access policies.
DevOps Mindset in a Linux Context
DevOps is as much about culture and process as it is about tools. In this part, the Linux-specific angle emphasizes:
- Automation over manual work
- Prefer scripts, playbooks, and pipelines to ad-hoc commands on individual servers.
- Ensure the same steps can run automatically on any Linux environment.
- Declarative configuration
- Describe what your systems and infrastructure should look like, letting tools handle how to reach that state.
- Use version control to track and review changes.
- Reproducibility and consistency
- A developer’s Linux environment, a CI runner, and a production server should be as similar as possible.
- Containerization and automation help make that reality.
- Observability
- Linux provides rich logs and metrics; cloud and DevOps tooling help you collect and interpret them
- You’ll integrate basic monitoring and logging into your workflows.
Practical Focus and Expectations
Throughout PART VI you will:
- Work mainly in text files: source code, YAML pipelines, configuration and Terraform files.
- Run tools and commands in the Linux terminal that:
- Build and test code
- Run CI jobs locally or in containers
- Apply configuration changes across machines
- Create or destroy cloud resources
You are not expected to become an expert in every named tool. Instead, you should:
- Understand how each tool fits into a larger DevOps and cloud workflow.
- Be able to follow and lightly modify simple real-world examples.
- Know what to look up later when dealing with more complex setups.
How to Approach This Part
To make the most of these chapters:
- Use a Linux machine or VM you can experiment on
- You’ll need somewhere to install packages, run compilers, and test scripts.
- Use version control for everything
- Keep your scripts, playbooks, and Terraform files in a Git repository from the beginning.
- Start small and iterate
- Begin with simple, local examples before involving remote servers or cloud APIs.
- Experiment safely
- When working with cloud providers, use small and clearly scoped test environments.
- Clean up resources to avoid unnecessary costs.
The following chapters will walk you step by step from local Linux development, through automated pipelines and configuration management, to fully managed Linux infrastructure in the cloud.