Cloud & DevOps
Containers, CI/CD, infrastructure as code, backups, observability and cloud costs.
Ansible: configuring many servers in a repeatable way
How agentless Ansible works over SSH: inventory, playbooks, idempotent modules, handlers, roles and variables, with an example that sets up a web server.
Autoscaling and load balancing: coping with traffic spikes
How load balancers and autoscaling work, vertical and horizontal scaling, metrics and thresholds, health checks and stateless applications explained.
How to choose a VPS: resources, location, backups and support
Practical criteria for choosing a virtual private server: shared or dedicated CPUs, memory, disks, bandwidth, datacenter location, backups and support.
CI/CD pipelines: from commit to release with no manual steps
What continuous integration, delivery and deployment are, how the stages of a pipeline are organized and which mistakes to avoid for fast, safe releases.
Cloud costs: understanding the bill and cutting it safely
Where cloud costs come from, the hidden items such as outbound traffic and forgotten resources, and the concrete techniques for reducing monthly spending.
Cloud snapshots and backups: why they are not the same thing
How disk and VM snapshots differ from real cloud backups: data consistency, separation from the account, immutability and long-term retention.
Containers: what they really are and why they changed deployment
What sets a container apart from a virtual machine, how images, layers and isolation work, and when containers make shipping software simpler.
Cron and systemd timers: automating scheduled jobs
How to schedule backups, cleanups and reports on Linux with cron and systemd timers: syntax, differences, logs, overlapping jobs and failure notifications.
Deployment strategies: rolling update, blue-green and canary
How to release a new version without downtime: rolling update, blue-green and canary compared, with their costs, risks and how to handle the database.
Development, staging and production: environments that match
Why separate environments are needed, how to keep them close to production, config via variables, realistic test data and twelve-factor principles.
Docker Compose: running multiple containers from one file
How to use Docker Compose to describe an app, its database and helper services in one YAML file: networks, volumes, variables and production use.
A well-written Dockerfile: small, secure, reproducible images
How to write an effective Dockerfile: base image, layer order, multi-stage builds, a non-root user and .dockerignore, with an annotated example.
GitOps: using Git as the source of truth for releases
What GitOps is, push versus pull models, how tools such as Argo CD and Flux work, how secrets are handled and when the approach is really worth adopting.
Handling a production outage and writing a useful postmortem
How to deal with a production outage: roles, priorities, communication, restoring before diagnosing, and a blameless postmortem that improves the system.
Infrastructure as code: principles, benefits and first steps
What infrastructure as code is, declarative versus imperative, why it reduces errors and drifting configurations, and how to introduce it gradually.
Kubernetes: the basic concepts and when it is really worth it
Pods, Deployments, Services, Ingress and namespaces explained with examples, how Kubernetes reconciliation works and when a project can do without it.
A brand-new Linux server: the first steps to make it secure
What to do in a Linux server's first hour: a personal user, SSH keys, firewall, automatic updates, exposed services and protection against login attempts.
Object storage: buckets, storage classes and mistakes to avoid
How S3-compatible object storage works, how it differs from disks and file systems, storage classes, versioning, permissions and accidental public buckets.
Observability: logs, metrics and traces to understand applications
What sets observability apart from monitoring, what logs, metrics and distributed traces are for, how to use them together and the role of OpenTelemetry.
Reverse proxies: Nginx, Caddy and Traefik compared
What a reverse proxy in front of web apps is for, what it does with TLS, caching and load balancing, and how to choose between Nginx, Caddy and Traefik.
RPO and RTO: designing a realistic disaster recovery plan
What RPO and RTO mean, how to set them for each service, which recovery architectures match each target and how to write the plan and test it in practice.
Secrets management: keeping passwords and keys out of code
Where to keep an app's passwords, tokens and API keys: environment variables, .env files, secret managers, rotation, and what to do if a secret leaks.
Serverless: how it works, when it pays off and its limits
What serverless means, how event-triggered functions work, the cold start problem, pay-per-use costs and when a traditional server is the better choice.
SLIs, SLOs and error budgets: measuring the reliability you need
How to define a service's reliability indicators and objectives, why one hundred percent is the wrong target and how to use the error budget in decisions.
Terraform in practice: providers, state, plan and modules
How Terraform works: providers and resources, the state file and where to keep it, the plan and apply cycle, variables, modules and the commonest mistakes.