Linux Foundation Certified IT Associate

The command line is the core skill of Linux work. You move around the filesystem, manage files and permissions, combine commands with pipes, edit text, and find help when you are stuck.

• The shell, prompts and basic navigation
• Creating, copying, moving and removing files
• Permissions and ownership
• Pipes, redirection and searching text
• Editing files in the terminal
• Finding help with man pages and the help flag

You build A shell exercise log that organizes a messy directory and reports on it using only commands.

Administrators keep systems working and safe. You manage users and groups, install and update software, start and stop services, read logs, and follow the habits that keep servers tidy.

• Users, groups and sudo
• Installing and updating software
• Services and how they start
• Reading system logs
• Scheduling routine jobs
• Administration habits: documentation, change control and backups

You build A newly set-up server with users, a running service, scheduled maintenance and a change log.

Almost every system talks to another. You learn how addresses, ports, DNS and common protocols work together, test connections with basic tools, and reach remote machines securely.

• IP addresses, subnets and gateways
• Ports, TCP and UDP
• DNS and how names become addresses
• HTTP and other everyday protocols
• Testing with ping, curl and ss
• Connecting remotely with SSH

You build A network map of a small lab, checked with the tools that show each link works.

When things fail, a method beats guessing. You work from symptoms to causes, use logs and tools to narrow them down, and plan backups and recovery so that data and services can come back.

• A troubleshooting method: symptom, hypothesis, test
• Using logs and monitoring to find causes
• Backup types and schedules
• Recovery point and recovery time objectives
• Restoring from a backup
• Writing up an incident

You build A backup and restore plan for a small server, with a restore actually performed and timed.

The cloud is rented infrastructure with its own vocabulary. You learn the service and deployment models, how virtualization makes sharing possible, and how a typical cloud account is organized.

• Infrastructure, platform and software as a service
• Public, private and hybrid clouds
• Virtualization and how providers share hardware
• Regions, zones and where workloads run
• Accounts, identities and billing
• Launching a virtual machine in a cloud

You build A virtual machine launched in a cloud account, reached over SSH and shut down with its cost noted.

Cloud systems are judged by whether they stay up, run fast and cost what you expected. You learn redundancy and scaling, how cloud networks are laid out, and how to budget and watch spending.

• Redundancy and failure domains
• Scaling up and scaling out
• Load balancers and health checks
• Virtual networks, subnets and firewalls
• Cost models and budgets
• Monitoring cost and usage

You build A cost and availability sketch for a small web service, with one single point of failure removed.

Everyone in IT handles security. You learn the core goals of confidentiality, integrity and availability, how people and systems prove identity, how sensitive data is protected, and what compliance asks of teams.

• Confidentiality, integrity and availability
• Authentication, authorization and multi-factor login
• Encryption at rest and in transit
• Handling sensitive and personal data
• Common threats: phishing, malware and weak passwords
• Compliance, policies and privacy rules such as GDPR

You build A basic security checklist for a small team, with the reason for each control.

Git is how teams keep track of changes to code and configuration. You create repositories, commit, branch and merge, share work through a remote, and see how reviews fit in.

• Repositories, commits and history
• Branches and merging
• Resolving a merge conflict
• Remotes: clone, push and pull
• Pull requests and code review
• What belongs in a repository and what does not

You build A repository with a history of branches and merges, shared through a remote and reviewed through a pull request.

DevOps joins building and running software into one habit. You learn its ideas and the pipeline from commit to release, then package and run an application in a container.

• DevOps goals and practices
• Continuous integration and delivery in outline
• What a container is and how it differs from a virtual machine
• Images and registries
• Running and inspecting containers
• Writing a simple Dockerfile

You build A small web application packaged in a container image and run on your machine and in the cloud.

IT work happens in teams and in projects. You learn project management basics, how requirements are analyzed, how applications are structured, and what open source licenses allow and require.

• Project phases, roles and common methods
• Agile approaches: Scrum and Kanban
• Requirements, user stories and functional analysis
• Application architecture: tiers, monoliths and services
• Open source licenses: permissive and copyleft
• Choosing and complying with a license

You build A project brief for a small application, with its requirements, architecture sketch and license choice.

Combine everything in one small project. You set up a Linux machine, run a service in a container, keep its code in Git, secure and back it up, and write the documentation another person would need.

• Planning the service and its environment
• Setting up the machine and the network
• Packaging and running the service
• Securing, backing up and monitoring it
• Writing the handover document

You build A documented service running in the cloud, with code in Git, security checks and a tested backup.