In smaller organizations, environments are often separated using Kubernetes Namespaces within the same cluster. In larger production environments, separate clusters are usually used for better isolation and security. For example, we might have separate clusters for Dev, Staging, and Production while using namespaces inside each cluster for application separation.

A ServicePort defines the port through which a Kubernetes Service exposes an application. It acts as an entry point and forwards traffic to the target port running inside the pods.

A Deployment is a Kubernetes object used to manage stateless applications. It ensures the desired number of pod replicas are running and handles rolling updates, rollbacks, and self-healing when pods fail.

EC2 gives us full control over virtual machines, including operating system management. Fargate is serverless for containers, so AWS manages the underlying infrastructure and we only focus on running containers.

Simple Routing: Routes traffic to a single resource.
Weighted Routing: Distributes traffic based on assigned weights.
Latency Routing: Sends users to the lowest latency endpoint.
Failover Routing: Redirects traffic to a backup resource during failures.
Geolocation Routing: Routes based on user location.
Multi-Value Routing: Returns multiple healthy endpoints.

A rotation policy automatically rotates encryption keys periodically. This improves security because old keys are replaced with new versions while maintaining access to encrypted data.

Minimum Capacity, Maximum Capacity, Desired Capacity, Scaling Policies, Health Checks, Cooldown Periods, these are main parameters in Auto Scaling because, these settings determine how instances are added or removed based on demand.

depends_on explicitly defines a dependency between resources. Terraform ensures the dependent resource is created only after the specified resource is successfully created.

After deployment, outputs can be viewed using ” terraform output output_name “

terraform taint marks a resource for recreation during the next terraform apply. It is useful when a resource becomes corrupted or needs replacement without changing the Terraform code.

Docker Compose allows us to define and run multiple containers using a single YAML file. It is commonly used for local development environments where applications require databases, APIs, and other services.

Multiple containers cannot directly use the same host port. Usually a reverse proxy or load balancer such as Nginx, Traefik, or HAProxy receives traffic on one port and forwards requests to different containers internally.

The EXPOSE instruction documents which port the container application listens on. It does not publish the port automatically but serves as metadata for users and tools.

I usually create separate Dockerfiles or use build arguments.

Example:

ARG PYTHON_VERSION=3.11
FROM python:${PYTHON_VERSION}

This allows different versions to be selected during the build process.

chmod 777 gives read, write, and execute permissions to everyone: owner, group, and others.

The number 5 at the beginning represents special permissions.

5 = SetUID (4) + Sticky Bit (1)

777 still means full permissions for owner, group, and others.

The sed command is commonly used.

Example:

sed -i ‘s/oldtext/newtext/g’ file.txt

Example:

grep “error” application.log

This searches for the word “error” inside the file.

Parallel stages allow multiple tasks to run simultaneously.

Like, unit testing, security scanning, and code quality checks can run in parallel to reduce pipeline execution time.

git merge combines branches and preserves history.

git rebase moves commits onto another branch and creates a cleaner linear history.

Staging is the intermediate area where changes are prepared before committing.

Using this command you can add file to the staging area:

git add file.txt

Blue-Green Deployment uses two identical environments.

Blue = Current Production

Green = New Version

Traffic is switched from Blue to Green after successful testing, reducing downtime and making rollback easier.

git stash temporarily saves uncommitted changes without committing them. It is useful when switching branches or pulling updates without losing work.

git commit saves changes to the repository history. And No, commit IDs usually change after a rebase because Git rewrites the commit history and creates new commit hashes.