Chasing Kubernetes wisdom • DevOps Engineer • laC addict • Building platforms
Houston, TX
Joined March 2011
- Tweets5.2K
- Following1.7K
- Followers3.5K
- Likes11K
clovis retweeted
The VPC DNS server is Route 53 Resolver. It's what your EC2 instance asks to look up a name. Route 53 hosted zones hold the records. For a private zone attached to your VPC, Resolver answers from those records; for a public domain, it resolves through public DNS.
clovis retweeted
The correct answer is A. Another VPC is already using the same CIDR.
A secondary CIDR block cannot overlap with an existing CIDR range in another VPC.
clovis retweeted
That is D my man.
You can add another VPC route but not the same size or larger.
If you already have /24 you can add /25.
clovis retweeted
If you’re a :
Network Engineer
Cloud Engineer
DevOps Engineer
Platform Engineer or SRE Cybersecurity Engineer Network Security Engineer Systems Administrator
or work in a related field,
let’s connect, learn, support each other, and share insights. 🤝
clovis retweeted
A good way to study or do quick math is you have four 8 bit octets (32) in an subnet mask.
First octet uses 8
Second octet uses 8
You used 16 bits, you need 4 more bits in the 3rd octet.
Last octet is 0
So your /20 is 255.255.240.0
clovis retweeted
Create a 2nd CIDR with the existing VPC, create new subnets from it.
Remember your CIDR is a pie that can be sliced up in different sizes. If you're not sure create a subnet that's larger. You cannot resize the original CIDR. Start with a topology, planning helps the execution.
clovis retweeted
the /16 means there are 16 leading 1's in the subnet mask. The subject mask is essentially:
11111111.11111111.00000000.00000000.
Each all-1s octet equals 255 because the bits double from the right: 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255. That produces the mask 255.255.0.0, so the first 16 bits identify the network and the remaining 16 bits identify hosts.
clovis retweeted
The way I learned
10.0.0.0 is the street or block
/8 /16 /24 /32 are the houses.
The larger the number the less the houses or usuable IPs.
/16 = 65,536 IPs
/32 = 1 IP
/24 is common with 256 IPs
Think backwards. 🤣🤣
clovis retweeted
/16 means the first 16 bits of the IP address identify the network, while the remaining 16 bits are available for devices.
For 10.0.0.0/16:
Network portion: 10.0
Device portion: the last two numbers
Address range: 10.0.0.0 to 10.0.255.255
Total addresses: 65,536
Subnet mask: 255.255.0.0
In simple terms, /16 says: Every IP address beginning with 10.0 belongs to this network.
Examples inside this network:
10.0.1.25
10.0.100.50
10.0.255.254
But 10.1.0.1 is outside it.
clovis retweeted
etcd has no concept of pods, deployments, etc.
API server is the component that understands both etcd's key-value pairs and Kubernetes' object model, plus auth, validation, and more.
Direct etcd access would mean every component reinventing it all.
clovis retweeted
Kubernetes Architecture Explained
When looking at a Kubernetes architecture diagram, pay close attention to the direction of the arrows. They show which component initiates the communication.
⚡️Control Plane Components:
1️⃣API Server
The entry point to the cluster. All requests pass through it.
2️⃣etcd
Stores the cluster state. Only the API Server communicates directly with etcd.
3️⃣Scheduler
Watches for unscheduled Pods and selects the best worker node for them.
4️⃣Controller Manager
Watches the cluster state and works to maintain the desired state.
⚡️Worker Node Components:
1️⃣Kubelet
Communicates with the API Server and ensures assigned Pods are running.
2️⃣Container Runtime
Pulls images and runs containers.
3️⃣Kube-proxy
Implements Service networking and routes traffic to Pods.
4️⃣CNI Plugin
Provides Pod networking and assigns IP addresses to Pods.
clovis retweeted
1ST REASON YOU MUST MOVE YOUR APP FROM DOCKER TO KUBERNETES: MANAGING CONTAINERS ACROSS MULTIPLE SERVERS.
⚠️You’ve deployed your application with Docker. Everything is running smoothly on a single server.
Now your online store has grown. Your team needs six copies of its API running across three servers.
With standalone Docker, you manage each server separately:
- Server 1: Start two API containers.
- Server 2: Start two API containers.
- Server 3: Start two API containers.
It works. But each Docker Engine manages the containers on its own server. It does not coordinate with the others.
To check all six containers, you check each server separately or build automation to collect that information.
Three servers might be manageable. What happens when you have thirty?
✅With Kubernetes, those servers become part of a cluster.
You create a Deployment that says: “Run six copies of this API.”
Kubernetes chooses suitable servers for those copies based on resource requirements and scheduling rules. You no longer deploy to each server individually.
You can also see where those copies are running through one command:
