Práctica de Docker y Kubernetes

A Docker image packages application code together with the runtime, libraries, and configuration as layered filesystem snapshots. It does not include a separate OS kernel.

FROM names the base image that the build starts from, such as FROM node:20.

COPY copies files or directories from the build context into the image filesystem.

docker build reads the Dockerfile in the build context and produces an image.

CMD provides the default command for the container and can be overridden at runtime.

ENTRYPOINT defines the main executable that runs when the container starts and is harder to override than CMD.

A Dockerfile is a text file that contains build instructions such as FROM, COPY, RUN, and CMD.

A container is a runnable instance of an image, isolated with its own filesystem, processes, and network.

docker ps shows running containers; adding -a also shows stopped containers.

docker run creates and starts a container from an image.

docker pull downloads an image from a registry such as Docker Hub to the local Docker daemon.

Docker Hub is a registry service for sharing and distributing container images.

Layers allow Docker to reuse cached build steps, reduce storage, and transfer only changed layers.

Volumes provide persistent storage that remains available after containers are removed or recreated.

The -v or --volume flag mounts a volume or host directory into the container.

A bind mount maps a directory on the host into a container path, so the container sees host files directly.

Named volumes are managed by Docker and persist independently of container lifecycle.

The bridge driver creates a private network on the host so containers can communicate through it.

The host driver removes network isolation and attaches containers directly to the host network.

Docker Compose defines multi-container applications in YAML and manages them with simple commands.

Compose looks for docker-compose.yml or compose.yaml by default.

docker compose up creates networks and containers for the services and starts them.

Each service in a Compose file defines how one container or group of containers should run.

The image key tells Compose which image to pull or build for the service.

The ports key publishes container ports to the host, for example 8080:80.

docker exec runs a command inside an already running container, which is useful for debugging.

docker logs prints the logs produced by a container. It is the standard command for viewing stdout and stderr output from a running or stopped container. docker ps lists containers, docker pull downloads images, and docker inspect shows detailed configuration rather than logs.

A registry stores images and allows clients to pull and push them.

docker tag creates a new tag for an image, often used before pushing to a registry.

docker push uploads a locally tagged image to a registry.

A Pod is the smallest deployable unit in Kubernetes; its containers share network and storage resources.

A ReplicaSet ensures that a specified number of pod replicas are running.

Deployments manage stateless workloads and support rolling updates and rollbacks.

DaemonSets ensure a copy of a pod runs on every eligible node, which is useful for logging and monitoring agents.

A Job creates one or more pods and tracks them until they complete successfully.

A CronJob creates Jobs on a schedule, similar to a cron entry.

StatefulSets provide stable pod identities, ordered deployment, and persistent storage for stateful apps.

A Service gives pods a stable virtual IP and DNS name and load balances traffic to matching pods.

LoadBalancer provisions an external load balancer and assigns the service an external IP.

Ingress exposes HTTP and HTTPS routes from outside the cluster to services inside it.

ConfigMaps keep configuration data separate from container images so the same image can run in different environments.

Secrets store sensitive data and can be mounted into pods or passed as environment variables.

kubectl apply -f creates or updates resources declared in a YAML manifest.

kubectl get pods lists pods and their status in the current namespace.

kubectl logs prints container logs from a pod. It is the standard Kubernetes command for troubleshooting application output. kubectl describe image is not a valid command, kubectl exec runs commands inside a container, and kubectl get events lists cluster events instead of pod logs.

Namespaces provide scopes for resources and help organize or isolate cluster objects.

Container resource requests and limits are defined in the container resources field of a pod spec.

A liveness probe tells kubelet when a container is unhealthy and should be restarted.

A readiness probe determines when a pod should receive traffic from a Service.

A PersistentVolumeClaim requests storage and binds to an available PersistentVolume.

A StorageClass defines storage provisioners, reclaim policies, and parameters for dynamic volume provisioning.

kubelet runs on each worker node and ensures containers in pods are running and healthy.

The control plane includes the API server, scheduler, controller manager, and etcd.

etcd is the distributed key-value store that holds the cluster state and configuration.

A node is a worker machine, physical or virtual, that runs pods through a container runtime and kubelet.

The Horizontal Pod Autoscaler changes the number of pod replicas based on metrics such as CPU utilization.

kubectl rollout status reports the progress of a Deployment update until it completes or times out.

RBAC controls which users and service accounts can perform actions on Kubernetes API resources.

ServiceAccounts provide an identity for workloads to use when talking to the API server.

imagePullPolicy controls whether the kubelet pulls an image always, only when absent, or never.

Deployment, StatefulSet, and DaemonSet are workload controllers; ConfigMap stores configuration data.

Services use selector, ports, and type; the image field belongs to a container or pod spec.

build, pull, and push manage images; docker run creates and starts a container from an image.

Named volumes, bind mounts, and tmpfs mounts are storage options; overlay is a network driver.

The API server, scheduler, and etcd are control-plane components; kubelet runs on worker nodes.

describe, logs, and exec provide details about a pod; docker push uploads images and does not debug pods.

Kubernetes supports liveness, readiness, and startup probes; networkProbe is not a built-in probe.

ClusterIP, NodePort, and LoadBalancer are Service types; Pod is a workload object, not a Service type.

docker ps lists running containers; docker ps -a also shows stopped containers.

kubectl apply -f file.yaml creates or updates resources from a manifest.

kubectl logs web prints the logs from the pod named web.

docker exec runs a command inside a running container. It is commonly used for debugging, inspecting files, or launching an interactive shell. The answer should be docker exec because that is the Docker command for this task.

kubectl rollout status deployment/name reports the progress of a rollout.

A Service provides a stable virtual IP and DNS name for a set of pods.

build creates images, run starts containers, push uploads images, and exec runs commands inside running containers.

Deployments manage stateless apps, StatefulSets manage stateful apps, DaemonSets run pods on every node, and CronJobs run scheduled jobs.

FROM sets the base, COPY adds files, CMD sets the default command, and EXPOSE documents a port.

ConfigMaps store config, Secrets store sensitive values, Services provide stable endpoints, and Ingress routes external HTTP traffic.

get lists resources, describe shows details, logs prints logs, and exec runs commands in a container.

A PersistentVolume is cluster storage, a PVC requests it, a StorageClass defines provisioning, and a Volume is the pod-level mount source.