Search
30 results for “cli”
Search results
What is a managed identity, and what problem does it solve compared to a service principal with a client secret?
A managed identity is an Entra ID identity automatically managed by Azure for a resource (a VM, an App Service, a Function), with credentials that Azure handles entirely, no client secret is ever stored, retrieved, or rotated by the application. A traditional service principal with a client secret requires that secret to be stored somewhere (a config file, a key vault) and rotated manually or via automation, which is itself a credential-management burden and a leak risk. Managed identities remove that burden for the common case of "this Azure resource needs to authenticate to another Azure service," which is why they're preferred whenever the workload runs on Azure compute.
Join a Client Computer to a Domain: Hyper-V Lab
Create a Windows client VM and join it to an Active Directory domain on Windows Server 2019, completing a realistic Hyper-V domain lab.
Linux Fundamentals
The command-line building blocks (navigation, permissions, processes, networking, services) every other Linux topic on this site assumes.
What is the difference between killing a process with SIGTERM and SIGKILL?
`kill <pid>` sends SIGTERM by default, a request asking the process to shut down, which well-behaved programs catch to close files, finish in-flight work, and exit cleanly. `kill -9 <pid>` sends SIGKILL, which the kernel delivers directly and a process cannot catch, ignore, or clean up after; it is terminated immediately, mid-instruction if necessary. SIGKILL is a last resort for a genuinely hung process; reaching for it by default risks corrupted files or orphaned resources that a graceful SIGTERM shutdown would have avoided.
Why does `ping` succeeding not guarantee an application on that host is reachable?
ping tests only ICMP echo reachability at the network layer; it confirms a host responds to the network, nothing about any specific service running on it. An application listening on a TCP port can be down, crashed, or blocked by a firewall rule that specifically targets that port while still allowing ICMP through, or conversely ICMP itself can be blocked while the actual service is reachable. Confirming an application is actually up requires testing the application layer directly, e.g. `curl` against its port or `ss -tulpn` to confirm something is listening at all.
What does `systemctl enable` actually do, and how is it different from `systemctl start`?
`systemctl start <service>` runs the service right now, in the current boot session only; it will not come back after a reboot. `systemctl enable <service>` creates the symlinks systemd uses to decide what to launch automatically during the boot sequence, so the service starts on every future boot, but does not start it immediately. The two are independent and commonly used together (`systemctl enable --now <service>`) precisely because neither one implies the other.
AWS Fundamentals
How AWS accounts, regions, identity, and core services fit together, with a practical CLI and access-denied troubleshooting workflow.
What is Azure Resource Manager (ARM) and why does every Azure operation go through it?
ARM is the deployment and management layer that every Azure operation, whether from the Portal, CLI, PowerShell, or an ARM/Bicep template, ultimately goes through. It provides a consistent API surface, handles authentication and authorization checks against Azure RBAC, and is what enables declarative deployment (submit a template describing desired resources, ARM figures out what to create/update). Because every path converges on ARM, access control and activity logging are consistent regardless of which tool was used to make a change.
What is an app registration in Entra ID, and why do workloads need one?
An app registration creates an application object that defines the application globally in its home tenant: client ID, redirect URIs, credentials, and requested API permissions. A service principal is the tenant-local instance that is actually assigned permissions and used during sign-in. Managed identities are a different Azure-managed form of service principal for Azure resources; you do not create or maintain an app registration or credential for them manually.
What is the difference between terraform plan and terraform apply, and why does that separation matter?
`plan` computes and displays the diff between current state and desired config without changing anything; it is a dry run. `apply` executes that diff against real infrastructure. Separating them means a human (or a CI approval gate) can review exactly what will be created, changed, or destroyed before anything actually happens, which is the core safety mechanism that makes infrastructure-as-code safer than manually clicking through a cloud console, nothing changes without a reviewed, explicit plan.
Production-Ready AKS GitOps with Terraform and ArgoCD
The DevOps Project That Finally Made Kubernetes, GitOps, and Terraform Click
Cloud IAM Fundamentals
How identities, roles, policies, scopes, and temporary credentials map across AWS, Azure, and Google Cloud, with practical access troubleshooting.
Why can't you rely on a Pod's IP address for service discovery?
Pods are ephemeral by design, Kubernetes kills and recreates them constantly (failed health checks, node drains, rolling deployments, autoscaling), and every new Pod gets a brand-new IP address. Hardcoding or caching a Pod IP breaks the moment that Pod is replaced. A Service solves this by providing a stable virtual IP and DNS name that always routes to whichever Pods currently match its label selector, regardless of how many times the underlying Pods have been replaced.
Cloud Networking Fundamentals
How VPCs, subnets, and security groups model network isolation, and why public versus private subnet is a routing decision, not a label.
What is the difference between readiness, liveness, and startup probes?
Readiness decides whether a Pod should receive Service traffic; a failed readiness probe removes the Pod from eligible backends without restarting it. Liveness decides whether a stuck container should be restarted. A startup probe protects slow-starting containers by delaying readiness and liveness checks until startup succeeds. Reusing one strict check for all three can create restart loops or route traffic too early.
Setting Up Clean Azure VNets, Subnets & Tagging
A Practical Lab Guide from Beginner to Pro.
Cloud Computing Explained: Models, Architecture, and Security
What cloud computing actually is: service and deployment models, core architecture, security, and how platforms like Azure fit real workloads.
What is the difference between authentication and authorization in a cloud IAM context?
Authentication answers "who is making this request", verifying an identity via credentials, a token, or a federated login. Authorization answers "is this identity allowed to do this specific action on this specific resource", evaluated after authentication succeeds, by checking the identity's attached policies against the requested action. A request can be perfectly authenticated (the caller genuinely is who they claim) and still be denied, because authorization is a separate check against what that identity is actually permitted to do.
Why does GitOps improve auditability compared to engineers running kubectl or terraform apply directly?
Every change to cluster state has to go through a Git commit, which means it inherits Git's existing history, authorship, and (if branch protection is configured) pull-request review, automatically. Direct `kubectl apply` access leaves no equivalent trail: two changes with the same effect are indistinguishable, there's no required review step, and reconstructing "who changed what and why" after an incident means digging through cluster event logs instead of reading a linear, reviewed commit history.
What problem does policy-as-code solve that a manual infrastructure change review does not?
A manual review depends on a human noticing a specific misconfiguration, an open security group, an unencrypted storage bucket, in a plan diff that may span hundreds of resources, and that scrutiny has to be repeated consistently by every reviewer on every change. Policy-as-code encodes the same rule once as executable logic and runs it automatically against every plan, so an overly permissive security group is caught the same way on the hundredth change as the first, without depending on which reviewer happened to be paying attention that day.
What distinct question does each of logs, metrics, and traces answer?
Metrics answer "what is happening, in aggregate, over time", cheap to store, good for dashboards and alerting thresholds, but they lose individual event detail. Logs answer "what exactly happened in this specific event", full detail but expensive to store and search at scale. Traces answer "where did time go across this one request as it moved through multiple services"; they reconstruct causality and latency across service boundaries that neither logs nor metrics show on their own. A mature observability setup uses all three together, correlated by shared identifiers like a request or trace ID.
Why is storing Terraform state locally a problem for a team, and what is the standard fix?
Local state is a single file on one person's machine, so another engineer can apply against stale or missing state and create conflicting changes. The standard fix is a remote backend that stores state centrally and supports locking. For the S3 backend, current Terraform supports native lock files with `use_lockfile = true`; DynamoDB-based locking is deprecated. The backend should also encrypt state and keep recoverable versions because state can contain sensitive values.
Why Every Container in Your Rolling Deploy Takes an Extra 10 Seconds to Stop
Why npm as PID 1 can prevent Node.js from receiving SIGTERM, trigger Docker's ten-second timeout, and end container shutdown with SIGKILL.
Azure Policy, Tags, and Resource Locks: Governance Guide
Implement Azure governance with Policy, resource tags, and locks: enforce standards, track cost and ownership, and protect resources from deletion.
Securing Azure Blob Storage: Network Rules, SAS, Immutability
A hands-on lab automating secure Azure Blob Storage using VNets, subnets, SAS tokens, and immutability.
Add an Additional Domain Controller to an Existing Domain
Add a second domain controller to an existing AD DS domain for redundancy and replication, built step by step in a Hyper-V lab.
How To Configure Virtual Network Peering in Azure
Connect Azure VNets with peering: when to use it, how routing works, and step-by-step setup with verification between two virtual networks.
Why would you use a NAT gateway instead of just putting a resource in a public subnet?
A NAT gateway lets resources in a private subnet initiate outbound connections to the internet (to pull a package, call an external API) while remaining unreachable from the internet for inbound connections; the NAT gateway only translates and forwards traffic the private resource itself initiated. Putting a resource directly in a public subnet with a public IP makes it directly reachable from the internet in both directions, which is unnecessary exposure for anything that only needs outbound access, like an application server that doesn't need to accept direct public traffic.
What is the difference between the Baseline and Restricted Pod Security Standards levels, and why are they cumulative?
Baseline blocks the most well-known container privilege-escalation paths, privileged containers, host namespaces, hostPath volumes, dangerous Linux capabilities, while still allowing a fairly permissive pod spec otherwise. Restricted inherits every Baseline rule and adds real hardening on top: it requires running as non-root, forbids privilege escalation outright, requires a restricted seccomp profile, and requires dropping all Linux capabilities except NET_BIND_SERVICE. A read-only root filesystem is not part of either standard, it's a separate hardening measure some organizations layer on as their own policy, on top of, not as part of, Restricted. They're cumulative by design, Restricted is Baseline plus more, so a workload that passes Restricted automatically satisfies Baseline too, and a cluster can apply different levels per namespace based on how much a given workload can be trusted.
What is the difference between monitoring and observability?
Monitoring means watching a predefined set of signals for known failure modes, dashboards and alerts built around questions you already knew to ask ("is CPU above 80%?"). Observability is a property of a system: how well you can answer new, previously-unasked questions about its internal state using only its external outputs (logs, metrics, traces), without shipping new code. Monitoring tells you something is wrong; observability is what lets you figure out why, including for failure modes nobody anticipated when the dashboards were built.