The issue opens pre-filled with this page title and URL.
Is your Kubernetes API server slow to answer? Do Pods take a long time to start? The problem may come from etcd, the database that stores the entire state of your cluster. This guide teaches you to diagnose and maintain etcd so you avoid outages and keep your infrastructure resilient.
What you will learn
Explain what Kubernetes expects from etcd: consistency, latency, security
Check the health of an etcd cluster in two minutes, and diagnose a slow or unstable etcd
Explain why backing up etcd matters, the full procedure being in the Back up and restore lesson
Carry out day-2 maintenance: compaction, defragmentation, quota, NOSPACE alarms
Monitor etcd with Prometheus and interpret the signals
This guide is for cluster administrators and SREs, in production as well as
when preparing for the CKA or the CKS. The concepts apply to kubeadm, k3s, RKE and
any distribution that relies on etcd.
The published outputs come from a Kubernetes 1.37 cluster, whose bundled
image is etcd 3.7.0. Two practical consequences shape the rest of this page.
First, the split of tools has changed: etcdctl queries the server, while
offline operations on a file or a data directory, such as verifying and restoring
a snapshot, belong to etcdutl. Second, the image is distroless: it contains
neither sh nor tar, only the two binaries. Every command in this guide takes
that into account.
Why etcd is critical in Kubernetes
Kubernetes has no memory other than etcd: no persistent configuration file, no secondary database. The API server is a stateless service that turns your requests into reads and writes in this key-value database. Understanding this coupling explains most control plane incidents, and it is the starting point of every diagnosis on this page.
Exact role of etcd in Kubernetes
etcd is the single source of truth of your Kubernetes cluster. Everything the API server knows, Pods, Services, Secrets, ConfigMaps, RBAC, is stored in etcd.
What etcd stores
Example
Desired state
"I want 3 replicas of nginx"
Current state
"2 Pods running, 1 pending"
Configuration
Secrets, ConfigMaps, ServiceAccounts
Metadata
Labels, annotations, finalizers
Leases
Controller leader election
Swipe to see more
If etcd is slow, the API server is slow. If etcd is down, the API server can no longer persist state: existing workloads keep running, but no change is possible (creations, deletions, updates). Depending on how long the outage lasts, even reads through the API can degrade.
Redundancy only protects against what it was designed for. Three members
protect against a machine failure, not against a slow disk, an unstable network or a quota reached: these
three hit all three members at the same time and make the cluster
unusable despite the quorum. Hence two non-negotiable hardware requirements,
SSDs and a latency below 10 ms between members.
What this guide is not
This is not a "history" page about etcd. The goal is 100% operational: commands to copy and paste, and runbooks to solve common problems.
The etcd mental model in 15 minutes
Three mechanisms are enough to explain almost every etcd incident: the Raft consensus, which decides who may write; MVCC, which keeps the history of changes and makes the database grow; and the transactions, watches and leases primitives, which Kubernetes depends on constantly. Knowing them avoids treating symptoms without understanding the cause.
Raft: leader, followers, quorum
etcd uses the Raft algorithm to guarantee data consistency across all members. Here is how it works:
The rule to remember is simple: without a quorum (a majority of members available), no write is possible.
Number of members
Quorum required
Fault tolerance
1
1
0 (none)
3
2
1 member
5
3
2 members
7
4
3 members
Swipe to see more
You can check this tolerance in one step, once the lab of the "Reproducible
lab with kind" section is deployed. Stop one of the three nodes, then ask for
a write: it goes through.
Terminal window
dockerstopetcd-lab-control-plane3
kubectlcreatenamespacelab-quorum
Output
namespace/lab-quorum created
Two members out of three do form the majority, so the cluster keeps
accepting writes. What changes is the diagnosis: the status command
explicitly reports the unreachable member and exits with code 1, which will
make your monitoring fail, rightly so.
Output of endpoint status --cluster
Failed to get the status of endpoint https://172.26.0.5:2379 (context deadline exceeded)
If you stopped a second node, the majority would be lost: etcd would no
longer accept any write. The workloads already started on the nodes still
running would keep running, since it is the kubelets that maintain them, not
etcd.
Restart each stopped node with docker start, for example
docker start etcd-lab-control-plane3, then check with
endpoint status --cluster that the three members answer. The following
sections assume all three members are running.
The number of members is therefore chosen within a narrow range. Three is
the standard and suits most clusters, it tolerates the loss of one machine.
Five is justified when downtime is very costly, it tolerates two. Beyond
five, the gain becomes theoretical while the cost is very real: every write
must be confirmed by the majority, and the larger the majority, the slower the
write. An even number brings nothing either, four members tolerating the same
single failure as three.
MVCC, revisions, compaction: why the database grows
etcd uses MVCC (Multi-Version Concurrency Control): every change creates a new revision without deleting the old one. This is what makes watches (real-time notifications) possible.
Without maintenance, the history piles up indefinitely.
Revision 1: pod-a created
Revision 2: pod-a modified (labels)
Revision 3: pod-a modified (replicas)
Revision 4: pod-a deleted
↓
All these revisions are kept!
Two maintenance operations address this:
compaction removes the old revisions and keeps the most recent one;
defragmentation reclaims the disk space after compaction.
Transactions, watches, leases
etcd offers three primitives that Kubernetes uses heavily:
Primitive
Kubernetes usage
Transactions
Atomic updates (create-or-update)
Watches
Controllers reacting to changes
Leases
Leader election, heartbeats
Swipe to see more
In short, etcd is simple (key-value) but demanding on the quality of storage and network.
etcd topologies in Kubernetes
Two ways of installing etcd coexist: on the control plane nodes, or on dedicated machines. The choice changes how you back up, how you renew certificates and how you upgrade the cluster. Identifying your topology is the prerequisite for any intervention, because file paths and maintenance commands depend on it.
Stacked etcd (on the control planes)
This is the default topology with kubeadm and RKE2, and that of most distributions that embed etcd. k3s is an exception: its documentation states that SQLite is the default datastore, and it only switches to embedded etcd when asked to, or when etcd files already exist on disk. Each control plane node hosts one etcd member, so the number of members follows the number of control planes: adding a third control plane adds a third etcd member.
The stacked topology is simple and needs fewer machines. In return, when a control plane goes down, you also lose an etcd member.
External etcd (separate cluster)
For critical environments, etcd can run on dedicated machines.
This topology is justified in four cases:
Resource isolation (dedicated CPU/RAM/disk)
A different backup policy
An etcd cluster shared between several K8s clusters
Strict latency requirements
It makes operations heavier: you have to manage additional certificates, configure the endpoints and keep separate maintenance procedures.
Reproducible lab with kind
kind (Kubernetes in Docker) creates a complete cluster in containers, in a few minutes and without a virtual machine. With three control plane nodes, you get a real three-member etcd cluster, hence a real quorum to observe. The commands of this guide run on this lab, except those of the cheat sheet and the runbooks, which assume an etcdctl installed on a node.
The point is to learn the gestures without risking a production cluster, and
they carry over: only the certificate paths change from one distribution to
another, the etcdctl commands are the same everywhere.
Deploy a kind cluster with 3 control planes
The number of role: control-plane lines directly sets the number of etcd members. Three is the minimum to tolerate the loss of one member without losing the quorum.
Allow about one minute. The "Configuring the external load
balancer" line only appears from two control planes on: kind puts a
load balancer in front of the three API servers, which a single-node
cluster does not have.
etcdctl is called directly, without going through a shell. This is a
requirement, not a preference: the etcd image shipped with Kubernetes,
registry.k8s.io/etcd:3.7.0-0 in 1.37, is distroless. It contains neither
sh nor tar, only the etcdctl and etcdutl binaries. A
kubectl exec ... -- sh -c '...' gets this answer:
exec: "sh": executable file not found in $PATH
Two practical consequences. Without a shell in the image, you cannot export
ETCDCTL_* environment variables, which etcdctl can nevertheless read: the
options are therefore passed as flags. And ETCDCTL_API=3 is no longer
needed: the v3 API has been the default since etcd 3.4 and the only one in 3.7,
where the variable triggers the unrecognized environment variable warning.
Finally, --endpoints=https://127.0.0.1:2379 is better than the node's address:
the command runs inside the etcd container, so the loopback address is always
right there.
The lab examples use the server.crt certificate, which also works as a client
certificate. On a real cluster, prefer healthcheck-client.crt and its key,
which kubeadm provides for this purpose: these are the ones used in the
"etcdctl cheat sheet" section.
Repeating these five lines on every command quickly becomes tedious. A
function defined on your workstation, not in the container, solves the
problem for the whole session:
In the diagnosis and maintenance sections, commands are shortened to
etcdctl --endpoints=https://127.0.0.1:2379 <command>. On the lab,
etcdctl-lab <command> does the same job: for example
etcdctl-lab endpoint health.
Validating connectivity
Three commands complement each other and do not answer the same question. endpoint health says whether a member accepts a write, endpoint status details its internal state, member list gives the declared membership. A member can appear in member list while being unreachable: it is this gap between the two views that reveals the failure.
Check the health of an endpoint
The test is not a simple connection opening: etcd actually submits a Raft proposal and measures how long it takes to be committed. A healthyendpoint therefore proves that the quorum works at that moment.
Expected output, taken from the lab on etcd 3.7.0. The table is wide,
sixteen columns, and is read diagonally: seven of them carry what is useful for
diagnosis.
The excerpt above omits five columns to fit on screen: STORAGE VERSION,
IS LEARNER, RAFT APPLIED INDEX, DOWNGRADE TARGET VERSION and
DOWNGRADE ENABLED. Your output contains them, and RAFT APPLIED INDEX is used
in the baseline check below. The following table says what to look at in the
seven useful columns.
Column
What it means
Expected value
IS LEADER
Exactly one member must be the leader
Exactly 1 true
DB SIZE
Size of the database file
Similar on all members
IN USE
Part of that file actually used
Close to DB SIZE
PERCENTAGE NOT IN USE
Space to reclaim by defragmentation
A few percent
QUOTA
Ceiling beyond which the alarm triggers
2.1 GB by default
RAFT INDEX
Replication index
Identical on all members
ERRORS
Active alarms
Empty
Swipe to see more
Two of these columns did not exist in older versions and change the way you
work. QUOTA displays the ceiling in black and white, there is no need to
assume it any more: 2.1 GB, that is the 2 GiB default of etcd, on a cluster
where no --quota-backend-bytes is set. And PERCENTAGE NOT IN USE directly measures what defragmentation would reclaim, which turns an
operation previously decided by gut feeling into a numbers-based decision.
List the cluster members
This list reflects the declared membership of the cluster, as etcd knows it, not the actual state of the machines. It is the reference to consult before adding or removing a member, and the ID column provides the identifier that member remove expects.
The rows follow the identifiers, not the names: do not read anything into the
fact that control-plane2 appears first.
Health and diagnosis: the checks that save you
During an incident, the classic mistake is to restart a member before understanding, at the risk of pushing the cluster below the quorum. The opposite method comes down to four checks with no side effects, then a targeted reading of the logs. The sections below give this sequence, then the frequent symptoms and their causes.
Baseline check (2 minutes)
Here is the sequence to run when there is a problem. The commands are written in short form: on the lab, etcdctl-lab endpoint health --cluster does the same job as the first one below, certificates included (the function is defined above).
The reported symptoms almost always concern Kubernetes, never etcd directly: a sluggish kubectl, Pods stuck in Pending, Deployments timing out. The link with etcd is confirmed or ruled out in a few commands.
Slow API server or timeouts
Three causes come up often, and each has its diagnostic command. Handle them in the order of the table: an active alarm blocks everything else and makes the other measurements impossible to interpret.
Symptom
Likely cause
Diagnosis
Action
Pods pending for a long time
etcd in alarm mode
alarm list
Resolve the alarm (see runbook)
Slow kubectl requests
Overloaded etcd or slow disk
endpoint health --cluster: high took duration
Check disk I/O, consider SSDs
context deadline exceeded
Unstable network between API server and etcd
etcd logs: slow request
Check network latency, MTU
Swipe to see more
Frequent elections (unstable leader)
Every election interrupts writes: a few leader changes per hour are enough to make the API server erratic. The counter below only makes sense relative to the age of the Pod, since an old cluster has necessarily accumulated legitimate elections.
kubectllogs-nkube-systemetcd-xxx--tail=200|grep-E"took too long|slow"
The messages indicate the type of slow operation (apply, commit, etc.)
Reading etcd logs usefully
etcd logs are voluminous and of no interest in day-to-day operations. Four patterns concentrate the useful information, and the filter below isolates them in one command.
Terminal window
kubectllogs-nkube-systemetcd-etcd-lab-control-plane--tail=100|grep-E"took too long|compact|alarm|elected leader"
Each pattern has a precise meaning:
took too long: slow requests (I/O or network)
compaction: compaction in progress
alarm: quota reached
elected leader: leader change
Why back up etcd?
An etcd snapshot is the only copy that lets you rebuild a cluster whose control plane is lost: it contains all the Kubernetes objects, Secrets included, and must therefore be treated as sensitive data, stored outside the cluster. The frequency of your snapshots sets the maximum acceptable data loss, and a snapshot never restored does not prove that you know how to go back. Taking, verifying and restoring a snapshot with etcdctl and etcdutl, then building a backup strategy, is the subject of the Back up and restore lesson. The official documentation Operating etcd clusters for Kubernetes describes the same approach from the Kubernetes side.
Day-2 maintenance: compaction, defrag, quota
Without intervention, an etcd database only grows until it hits its quota and blocks the cluster. Two distinct operations prevent this, and the order matters: compaction removes the history that has become useless, defragmentation gives the freed space back to the file system. The quota is the safeguard that triggers the alarm when these two gestures have been neglected. The etcd project details these operations in its etcd Maintenance page.
Compaction
Compaction removes the old revisions to limit the growth of the database. It is irreversible: after compaction at revision N, no historical read earlier than N is possible any more, which interrupts the watches still attached to those revisions. In practice, this does not bother Kubernetes, whose controllers resynchronize automatically.
# Defragment a single member (etcd must be running)
etcdctldefrag--endpoints=https://127.0.0.1:2379
Expected output:
Finished defragmenting etcd member[https://127.0.0.1:2379]. took 25.969208ms
To defragment a stopped etcd (offline maintenance):
Terminal window
# Stop etcd, then:
etcdutldefrag--data-dir/var/lib/etcd
The offline variant is used in two cases: reclaiming a lot of space at
once before restarting a member, and taking advantage of a maintenance
window that is already planned. On a running cluster, prefer the online form,
member by member.
Recommended procedure (online):
Defragment a follower
Check its health (endpoint health)
Defragment the next follower
Defragment the leader last
Measuring what defragmentation reclaims
The value of the operation can be measured, and the PERCENTAGE NOT IN USE column
gives it directly. Here is the state of two lab members after a compaction,
but with defragmentation run on only one of them:
│ ENDPOINT │ DB SIZE │ IN USE │ PERCENTAGE NOT IN USE │ IS LEADER │
Both members hold exactly the same data, Raft takes care of that. Yet the
defragmented member takes 684 kB against 2.1 MB for the other, 65% of
which is dead space. Two lessons. Compaction alone gives nothing back to the
disk, it merely marks revisions as useless. And defragmentation works member by
member: a cluster where only one member has been processed stays unbalanced
until you go through the others.
It is also the measurement that lets you decide. Below a few percent,
defragmenting gains nothing and costs a write interruption. Beyond several
tens of percent, the operation is justified.
Quota and NOSPACE alarm
By default, etcd applies a quota of 2 GiB, that is 2,147,483,648 bytes (the QUOTA column shows it rounded, 2.1 GB). A --quota-backend-bytes option in the etcd Pod manifest, /etc/kubernetes/manifests/etcd.yaml on kubeadm, overrides this value. When the quota is reached:
etcd knows neither namespaces, nor ServiceAccounts, nor Kubernetes RBAC: whoever accesses the database accesses the whole cluster, including the Secrets stored in clear text if encryption at rest is not enabled. The priority is therefore to close network access and enforce certificate authentication, before even talking about fine-grained rights.
Mandatory mTLS
etcd must never be exposed without TLS. All communications must be encrypted:
Communication
Ports
Certificates required
Client → etcd
2379
ca.crt, server.crt, server.key
etcd → etcd (peers)
2380
peer.crt, peer.key
Swipe to see more
etcd RBAC (advanced cases)
For external or shared etcd clusters, you can enable authentication. This mechanism of users and roles internal to etcd has nothing to do with Kubernetes RBAC: it splits rights by key prefix, not by resource or by namespace. On an etcd dedicated to a single Kubernetes cluster, it brings nothing more than mTLS and complicates the renewal of access:
Terminal window
# Enable authentication
etcdctlauthenable
# Create a user
etcdctluseraddadmin--new-user-password="***"
# Create a role
etcdctlroleaddreadwrite
etcdctlrolegrant-permissionreadwritereadwrite/
# Assign the role to the user
etcdctlusergrant-roleadminreadwrite
Monitoring and alerting
etcd incidents are almost always announced: the disk latency drifts, the database approaches the quota, the leader changes more often. Watching the right metrics turns a control plane outage into a simple planned maintenance operation. You still have to alert on the right signals and with thresholds calibrated to your hardware. The etcd Monitoring page of the project describes all the metrics.
Prometheus metrics
etcd exposes its metrics on /metrics (port 2379 with TLS). The key metrics to watch:
Metric
Description
Initial threshold
Notes
etcd_server_has_leader
Presence of a leader
!= 1
Critical, immediate action
etcd_server_leader_changes_seen_total
Leader changes
> 3/hour
Adjust if the network is unstable
etcd_disk_backend_commit_duration_seconds
Disk write latency
p99 > 25ms
On NVMe SSD, expect < 10ms
etcd_network_peer_round_trip_time_seconds
Network latency between peers
p99 > 50ms
Depends on the distance between nodes
etcd_mvcc_db_total_size_in_bytes
Database size
> 80% of the quota
Warning at 80%, critical at 95%
etcd_server_proposals_failed_total
Failed Raft proposals
> 0
Any failure = investigate
Swipe to see more
These values are starting points, not truths. An alert threshold
copied from a guide produces either noise or silence. Observe the trends of
your own cluster over seven to thirty days, then set the thresholds from what
you see and from the service commitment you have to meet.
PrometheusRule example
These three alerts cover the real emergencies: no leader, disk too slow, quota about to be reached. The for field avoids false positives by requiring the condition to last, and it is deliberately short for the missing leader, which must never persist beyond one minute. The PrometheusRule object assumes the Prometheus operator is installed.
summary: "etcd database close to the quota (> 80%)"
etcdctl cheat sheet
This summary gathers the commands of the guide in a copyable form. The ETCDCTL_CACERT, ETCDCTL_CERT and ETCDCTL_KEY variables replace the --cacert, --cert and --key options: exporting them once shortens all the following commands.
These commands run on the node, with an etcdctl installed on the
machine, and not in the distroless container. Install it from the
official archive of the etcd project, verifying its checksum, and not from your
distribution's package: the Back up and restore lesson
gives the commands. In this context, environment variables can be used again and
spare you from repeating the paths:
These four commands change nothing and are safe in production. The --cluster option widens the question to all members from a single reachable endpoint.
Defragmentation targets a specific endpoint, never the whole cluster: it is the only command on this page that you must run member by member, ending with the leader.
Reading etcd keys directly bypasses the API server, hence all the access and audit controls of Kubernetes; the values are serialized in protobuf and hard to read. Reserve these commands for diagnosis, on a test cluster, and never write to etcd by hand.
These four procedures are followed during an incident, without prior thought. Each starts from an observable symptom, confirms the hypothesis with a command, then applies the fix in an order that does not make the situation worse. Keep them accessible outside the cluster: an unavailable control plane often makes the internal documentation unreachable along with it.
The commands in this section assume an etcdctl installed on the node
and the certificates already configured, as indicated just above.
NOSPACE alarm
The cluster no longer accepts any write as long as the alarm is armed, and it does not clear by itself: disarming is mandatory, even after freeing space. The full procedure (alarm list, compaction, member-by-member defragmentation, alarm disarm) is that of the Quota and NOSPACE alarm section. To check the result, run endpoint status --cluster --write-out=table again: the DB SIZE column must have decreased.
Loss of quorum
Below the quorum, etcd refuses any write: the cluster can no longer change state, and the API can become outright unavailable, with no "read-only" mode to count on, as measured in the Control plane high availability lesson. The switch is abrupt: on three members, losing the second one takes you from a degraded but working cluster to an unusable one.
Identify the members that are down: etcdctl --endpoints=https://127.0.0.1:2379 member list --write-out=table
If only 1 member out of 3 is down: wait for it to come back or replace it
If 2 or more members are down: the quorum is lost. First try to restart them (machine, disk, network): if their data is intact, they rejoin the cluster and the quorum comes back, without any restore. If their data is lost, restoring from a snapshot with etcdutl snapshot restore becomes the only way out, a procedure detailed in the Back up and restore lesson
Slow etcd (I/O)
Every etcd write waits for a synchronized disk write on the majority of members: storage latency therefore directly affects that of the API server. This runbook is used to tell a disk problem from a network problem.
etcdctl --endpoints=https://127.0.0.1:2379 endpoint health --cluster → note the took duration of each member
Check the network latency: ping <PEER_IP>, which must stay under 10 ms
Fix: migrate to an NVMe SSD, improve the network
Expired certificates
The etcd certificates generated by kubeadm are valid for one year. On a cluster that has never been upgraded, they expire silently and the control plane goes down all at once, without any apparent configuration change.
The typical symptom is the transport: authentication handshake failed error. On the API server side, it often comes from apiserver-etcd-client, the client certificate the API server presents to etcd: it expires at the same time as etcd's. To confirm, then fix:
Check the expiration: sudo openssl x509 -in /etc/kubernetes/pki/etcd/server.crt -noout -dates, then the same command on /etc/kubernetes/pki/apiserver-etcd-client.crt
Renew with kubeadm: sudo kubeadm certs renew etcd-server, sudo kubeadm certs renew etcd-peer and sudo kubeadm certs renew apiserver-etcd-client, or sudo kubeadm certs renew all to renew everything at once
Make etcd reload its certificates: the serving certificate reloads by itself; for the others, nothing guarantees it.
A measurement of 13 November 2026 (kubeadm 1.37.2) shows that after kubeadm certs renew etcd-server, etcd served the new serving certificate on port 2379 in under 25 seconds, without a restart or a new container. This measurement covers neither etcd-peer, the certificate for exchanges between members, nor client certificates such as apiserver-etcd-client. The kubeadm documentation asks you to restart the control plane Pods after a renewal: so restart the etcd Pod by moving its manifest out of /etc/kubernetes/manifests/ and putting it back. The Renewing certificates section of the kubeadm lesson shows this restart step by step.
Restart the kube-apiserver, the controller-manager and the scheduler: the API server must reread apiserver-etcd-client, and the other two only read the client certificate of their kubeconfig at startup. Move their manifests out of /etc/kubernetes/manifests/ one by one, wait until sudo crictl ps no longer shows the container, then put the manifest back. Plan for an API outage of about 41 seconds for the four restarts (measurement of 13 November 2026, kubeadm 1.37.2). The Renewing certificates section of the kubeadm lesson details this gesture
Copy admin.conf to ~/.kube/config: this file carries an expired client certificate, and kubectl keeps failing after renew all until it is replaced. Run sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config then sudo chown $(id -u):$(id -g) $HOME/.kube/config, as in the Renewing certificates section of the kubeadm lesson
Pre-production checklist
These eight points are the ones whose absence turns an ordinary incident into a lost cluster. The first two take precedence over all the others: without a backup restored at least once and without an alert on the presence of a leader, the rest will not save you.
Automated backups, tested (successful restore)
Monitoring: alerts on leader, latency, disk space
SSD: storage with latency < 10ms
Network: latency < 10ms between etcd members
TLS: mTLS enabled for clients and peers
Quota: configured and monitored
Maintenance: auto compaction + scheduled defrag
Documentation: runbooks accessible to the team
Hands-on practice
The lab replays these gestures on a kubeadm cluster in virtual machines, where etcd runs in a static Pod (a Pod that the kubelet starts from a manifest) whose image contains etcdctl. With etcdctl and the etcd certificates, you read the member ID, its client endpoint and its health, then the space quota this etcd applies, in bytes. You record these answers in the ~/etcd/reponses.yaml file.
The setup then inflated the database and compacted it: it keeps a large, almost empty file. You defragment it so that it gives that space back. The validation covers three states: the answers match what etcd says about itself, the quota is the one the Pod really applies (its option, or the default value), and the database has given back at least half of the size it had after the inflation.
Key takeaways
Three members protect against a machine failure, not against a slow disk, an unstable network or a quota reached: these causes hit all members at once.
An etcd cluster has three or five members: an even number brings nothing, and beyond five every write gets slower.
Storage must be an SSD, because a slow disk slows every write, hence the API server.
A backup is only worth something if its restore has been tested: the procedure is in the Back up and restore lesson.
Compaction then defragmentation prevent the NOSPACE alarm; defragmentation is done member by member, leader last.
An etcd exposed without mTLS, for clients as well as for peers, puts the whole cluster at risk.
Test your knowledge
This quiz covers the etcd questions from the CKA certification curriculum. A score below 80% points to the sections to reread.
Knowledge check
Check what you have learned with this interactive quiz
7 questions
5 min
80% to pass
How it works
The timer starts when you click Start
Multiple choice, true/false and short answer questions
You can move between questions
Detailed results are shown at the end
Starts the quiz and the timer
⏱️--:--
0 / 7
Review
(0/0)
--:--
0%
0Correct
0To review
0:00Time
-Level
Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.