Private corporate batches, live online cohorts and 1-on-1 mentoring in the Raft-backed key-value store behind Kubernetes — quorum, MVCC, watches, backup and recovery — taught by a practitioner who runs it in production.
20 years across DevOps, SRE and Security · 10,000+ engineers trained · Trained teams at JPMorgan Chase, Verizon, Nokia and the World Bank
Principal DevOps Engineer & Architect
Rajesh teaches etcd from the consensus layer up — Raft leader election and log replication, why quorum arithmetic decides cluster sizing, and how the v3 MVCC keyspace, revisions and compaction actually behave. Sessions cover the API as engineers use it, including transactions, watches from a revision and lease-driven leader election, and then the operational core: snapshot backup and restore, member add and remove, defragmentation, alarm handling, TLS and RBAC, and the disk and latency tuning that decides whether a Kubernetes control plane stays responsive.
Twenty years across DevOps, SRE and Security, in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe and others. He has trained engineers at JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus — more than 10,000 people personally. He teaches what he runs, not what he reads.
You are booked with a named engineer, and that is who turns up. Marketplaces and larger providers rotate whoever is free, so the person who sold you the agenda is rarely the person teaching it.
The same trainer is available for the next engagement, which matters when a team builds on what it learned last time.
Your batch is assigned a named trainer before it starts, and that is who teaches it. See the full faculty.
Engagements are matched on the tool, not the calendar. For etcd that means a trainer who has run it in production — the Raft-backed key-value store behind Kubernetes — quorum, MVCC, watches, backup and recovery — rather than whoever is free that week. You are told who is teaching before you commit, and that person is on the discovery call that shapes the agenda.
Where a batch is large enough to need a second trainer, the pairing is declared up front. The lead trainer stays accountable for the syllabus and the assessment either way.
Principal DevOps Engineer & Architect
Twenty years across DevOps, SRE and Security in principal and architect roles at PayPay, SoftwareAG, ServiceNow, JDA Software, Intuit, Adobe, IBM/Emptoris, Ness, MindTree and Accenture. He has trained more than 10,000 engineers personally, at organisations including JPMorgan Chase, Verizon, Nokia, the World Bank, VMware, Oracle, Mercedes-Benz and Airbus. He teaches what he runs, not what he reads.
Teams of 8–30
Custom agenda, your timezone, onsite or online, NDA-friendly.
Request a quoteIndividual engineers
A private instructor and a curriculum built around your goal.
₹99,999Individuals who want peers
Scheduled batch, max 8 to 10 hours of live instruction.
₹34,999A private batch starts with a discovery call. We look at the stack you actually run — the CI system, the cloud, the constraints — and map the agenda onto it, so examples use your topology rather than a generic one.
Delivery is onsite at your premises, live online, or hybrid, scheduled around your release calendar rather than ours. Batches run 8 to 30 engineers.
Every attendee leaves with recordings, slides, lab repositories and a completion certificate. You receive an attendance and assessment report. Invoicing supports PO and GST.
Talk to us about a private etcd batchetcd is a distributed key-value store that provides strongly consistent, linearizable reads and writes across a small cluster of machines. Consistency comes from Raft: one member is elected leader, every write is appended to a replicated log, and a write is acknowledged only once a majority of members have durably persisted it. Quorum is therefore the governing fact of etcd operations — a three-member cluster tolerates one failure, a five-member cluster tolerates two, and an even member count adds cost without adding fault tolerance.
The v3 data model is a flat, revision-versioned keyspace stored in a bbolt B+tree. Every write increments a global revision, and previous revisions are retained until compaction removes them. That single design choice gives etcd its most useful properties: reads at a historical revision, watches that stream ordered events from any revision without missing anything, and mini-transactions that compare a key's revision or version before writing. Leases attach a TTL to keys, which is what makes registration, expiry and leader election expressible in the API rather than in application code.
In practice etcd is met through Kubernetes, where it holds every API object and its health is indistinguishable from cluster health. That places specific operational demands on it: write latency is dominated by fsync on the write-ahead log, so disk behaviour matters more than CPU; the default storage quota triggers a NOSPACE alarm that makes the cluster read-only; and compaction plus defragmentation are routine work rather than emergencies.
Every Kubernetes cluster has an etcd behind it, and most teams operating one have never read its API, tuned its disks, or restored it from a snapshot. That gap stays invisible until the day the control plane will not accept writes, and then it becomes the only thing that matters.
The failure modes are specific and learnable. A cluster that loses quorum does not degrade gracefully — it stops accepting writes entirely, and recovering it means understanding member lists, data directories and forced single-member restore rather than guessing at restart order. A cluster that fills its storage quota goes read-only with an alarm that survives restarts until it is explicitly disarmed. A cluster on slow or shared disk produces leader elections and apply latency that surface as unexplained API server timeouts several layers up.
Beyond Kubernetes, etcd remains the default coordination primitive for distributed systems that need leader election, distributed locking or service registration with expiry. Building those correctly on leases, transactions and watches — rather than on polling and hope — is a skill that transfers well past any single platform.
Distributed coordination before the tool. Why shared state across machines is hard, what strong consistency buys and costs, and where etcd sits against Consul, ZooKeeper and an ordinary database.
Topics: The distributed coordination problem · Strong consistency and linearizability · etcd against ZooKeeper, Consul and a relational store · Where etcd is the wrong choice · etcd in the Kubernetes control plane · v2 versus v3 and why the difference matters
The consensus algorithm as an operator needs it. Terms, leader election, log replication and commitment, then the arithmetic that decides cluster size and the behaviour of a cluster that loses majority.
Topics: Raft terms, elections and heartbeats · Log replication and commit index · Quorum arithmetic and fault tolerance · Why even member counts are wasteful · Static bootstrap, discovery and runtime reconfiguration · member add, remove, promote and learner nodes · Behaviour under network partition
How data is actually stored. The flat keyspace, the global revision counter, key version and create/mod revisions, the bbolt backend, and why keeping history is the source of both etcd's power and its disk growth.
Topics: Flat keyspace and key prefixes · Global revision, create_revision, mod_revision, version · MVCC and historical reads · The bbolt B+tree backend · Write-ahead log and snapshots on disk · The data directory layout · Why history accumulates and must be compacted
The five operations everything else is built from. Ranged reads and prefix queries, mini-transactions with compare-and-swap semantics, watches that stream ordered events from a revision, and leases that give keys a lifetime.
Topics: put and range, prefix and key-range queries · Sorting, limits and pagination · txn: compare, success and failure branches · watch from a revision and event ordering · Compaction and the required-revision-compacted error · lease grant, keep-alive, revoke and TTL behaviour · etcdctl and the gRPC API · Linearizable versus serializable reads
What etcd is actually used for. Distributed locking, leader election, service registration with automatic expiry, and configuration distribution — each built from transactions, leases and watches rather than from polling.
Topics: Distributed locks and lock fairness · Leader election on leases · Service registration and TTL-based deregistration · Configuration distribution with watches · Barriers and queues · Failure semantics: what happens when a client dies · Anti-patterns: etcd as a general database
Locking down a store that holds every secret in the cluster. Peer and client TLS with a real certificate authority, client certificate authentication, the user/role/permission model, and rotation without downtime.
Topics: Peer TLS between members · Client TLS and certificate authority design · Client certificate authentication and common-name mapping · Enabling auth, root user and auth token types · Users, roles and key-range permissions · Certificate rotation without downtime · Protecting the data directory at rest
The day-2 work that decides whether an incident is a ten-minute event or an outage. Snapshots and their verification, restore into a new cluster, revision compaction, defragmentation, and the alarm system that makes a full cluster read-only.
Topics: etcdctl snapshot save and status · Restoring a snapshot into a new cluster · Restore with force-new-cluster after quorum loss · Automatic and periodic revision compaction · Defragmentation and its blocking behaviour · quota-backend-bytes and the NOSPACE alarm · alarm list and alarm disarm · Backup scheduling and offsite retention
The specific case almost everyone actually runs. How the API server uses etcd, stacked versus external topologies, disk and latency requirements, encryption at rest for Secrets, and reading the metrics that predict a control-plane incident.
Topics: How kube-apiserver uses etcd: watch cache and resource versions · Stacked versus external control-plane topology · Disk requirements, fsync latency and IOPS · heartbeat-interval and election-timeout tuning · Encryption at rest for Kubernetes Secrets · Key metrics: disk_wal_fsync_duration, backend_commit_duration, leader changes · Prometheus alerting for etcd health · Control-plane disaster recovery and upgrade sequencing
We rebuild the agenda around the tools you actually run.
Request a custom agendaBring up a three-member cluster, kill the leader under write load, and trace the term change, election and log convergence in the logs.
Build a client that seeds from a range read at a revision and then watches from that revision, and prove it survives disconnection and compaction.
Run leader election across three processes on leases, then kill the leader mid-operation and measure how long failover takes.
Issue a certificate authority, secure peer and client traffic, then restrict a client to one key prefix and prove it cannot read outside it.
Destroy two of three members, recover with force-new-cluster, then rebuild the whole cluster from a snapshot and verify data integrity.
Push a Kubernetes etcd past its storage quota until the API server rejects writes, then compact, defragment, disarm the alarm and restore service.
Billed yearly at ₹9,996
Max 8 to 10 hours of live instruction
Full program, private instructor
8–30 engineers · custom agenda · onsite or online · PO and GST invoicing
Refunds. If we cancel or postpone a cohort, you get a full refund within 15 days. There is no money-back guarantee otherwise.
Terms. Course material remains licensed to the attendee. Read the terms.
Your data. We don't share it with third parties. Privacy policy.
Certificate of completion
Great learning experience from a very knowledgeable instructor with well-prepared course notes. The lab exercises on AWS instance work well to learn the hands-on side of the course.
Rajesh is a very good trainer I have experienced in DevSecOps training. The number of contents in different topics he has posted on the DevOpsSchool public website are amazing and user friendly for beginners and experienced professionals.
The trainer (Rajesh) provided very good sessions on SRE profession. Not only hands-on learning on the tools but also SRE mindset.
Very good training session. Well explained from the basics to the complex concepts. Also tried to cover practicals and demos within the 3 hour sessions. The learning content and videos are of a great deal of help.
Basics explanation was exemplary from Rajesh where he dealt with complicated topics to be simple. Great learning stuff personally for me.
Very detailed explanation and has lots of patience in attending the questionnaire. Thanks again for your wonderful sessions.
| What matters | YouTube + blogs | Generic online course | Freelance marketplace | DevOpsSchool |
|---|---|---|---|---|
| Named practitioner | No | Rarely | Varies per booking | Yes — same trainer each time |
| Production experience | Unknown | Unknown | Unverified | 20 years, named employers |
| Custom agenda | No | No | Sometimes | Built from your stack |
| Onsite delivery | No | No | Sometimes | Yes |
| Lab environment | None | Sandbox that expires | Varies | Your own cloud — skill goes with you |
| Assessment | None | Quiz | Rarely | Assignments + capstone per module |
| Per-attendee certificates | No | Sometimes | Rarely | Yes |
| Corporate invoicing | No | Limited | Varies | PO and GST |
| Post-training support | None | Forum, time-limited | None | Lifetime forum access |
Tell us the team, the stack and the timeline. You'll get a straight answer, not a sales sequence.
Talk to an advisorPrefer to call or email?
More ways to reach us on the contact page.