Back-end Web Developement Server Management Syllabus

Server Management syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Server Management in Back-end Web Developement, not a summary of it.

1. 1

   Web Servers

   2 topics

   • Nginx
   • Apache
2. 2

   Containerization

   2 topics

   • Docker
   • Kubernetes
3. 3

   CI/CD

   3 topics

   • Jenkins
   • GitHub Actions
   • GitLab CI

Server Management flashcards for Back-end Web Developement

20 of 50 cards from the Server Management deck — real questions with worked answers.

1. What is Nginx and what architecture does it use to handle concurrent connections?

   Nginx is a high-performance web server, reverse proxy, load balancer, and HTTP cache. It uses an asynchronous, event-driven (non-blocking) architecture with a master process and multiple worker processes, letting a single worker handle thousands of concurrent connections in one event loop.

2. In Nginx, what is the difference between a reverse proxy and a forward proxy?

   A reverse proxy (Nginx's typical role) sits in front of backend servers and forwards client requests to them, hiding the backends. A forward proxy sits in front of clients and forwards their requests out to the internet, hiding the clients.

3. Which Nginx directive defines a group of backend servers for load balancing, and what is the default balancing method?

   The `upstream` block defines the backend server group. The default load-balancing method is round-robin (requests distributed sequentially); other methods include `least_conn` and `ip_hash`.

4. What is the purpose of the Nginx `location` block?

   A `location` block matches request URIs and defines how Nginx processes requests to that path — e.g., serving files, proxying (`proxy_pass`), rewriting, or applying access rules. Matching can be exact (`=`), prefix, or regex (`~`, `~*`).

5. What are the default HTTP and HTTPS ports, and which Nginx directive sets the listening port?

   HTTP defaults to port 80 and HTTPS to port 443. The `listen` directive inside a `server` block sets the port, e.g., `listen 443 ssl;`.

6. How does the Apache HTTP Server's Multi-Processing Module (MPM) 'prefork' differ from 'event'?

   prefork uses multiple single-threaded processes (one process per connection, no threading — safe for non-thread-safe modules but memory heavy). event is a threaded MPM (worker-based) that dedicates a separate listener thread to manage keep-alive connections, scaling better for high concurrency.

7. What is the main configuration file of Apache HTTP Server, and what file provides per-directory overrides?

   The main config file is `httpd.conf` (or `apache2.conf` on Debian/Ubuntu). `.htaccess` files provide decentralized, per-directory configuration overrides that Apache reads at request time.

8. Name one key architectural difference between Nginx and Apache in handling connections.

   Nginx uses an event-driven, asynchronous model where one worker handles many connections without a thread/process per request. Traditional Apache (prefork/worker) tends toward a process/thread per connection, which consumes more memory under high concurrency.

9. What is a Docker image versus a Docker container?

   A Docker image is a read-only, layered template (built from a Dockerfile) containing application code, dependencies, and runtime. A container is a running (or stopped) writable instance of an image — the live process with its own filesystem layer, network, and namespaces.

10. What is a Dockerfile and name three common instructions?

    A Dockerfile is a text script of instructions used to build a Docker image. Common instructions: `FROM` (base image), `RUN` (execute a command during build), `COPY`/`ADD` (add files), `CMD`/`ENTRYPOINT` (default runtime command), `EXPOSE` (document a port).

11. In Docker, what is the difference between the `CMD` and `ENTRYPOINT` instructions?

    `ENTRYPOINT` sets the fixed executable that always runs when the container starts. `CMD` provides default arguments (or a default command) that can be overridden at `docker run`. When both are set, `CMD`'s values are passed as arguments to `ENTRYPOINT`.

12. What is a Docker volume and why is it used?

    A Docker volume is a persistent storage mechanism managed by Docker, living outside the container's writable layer. It is used to persist data beyond a container's lifecycle and to share data between containers, since container filesystems are ephemeral.

13. What does Docker layer caching do, and why order Dockerfile instructions carefully?

    Each Dockerfile instruction creates a cached layer; on rebuild, Docker reuses cached layers until it hits a changed instruction, then rebuilds everything after it. Placing rarely-changing steps (like dependency installs) before frequently-changing steps (like copying source) maximizes cache reuse and speeds builds.

14. What is Docker Compose used for?

    Docker Compose defines and runs multi-container applications using a single declarative YAML file (`docker-compose.yml`). It specifies services, networks, and volumes, and lets you start the whole stack with `docker compose up`.

15. What is the difference between `docker run` and `docker exec`?

    `docker run` creates and starts a new container from an image. `docker exec` runs an additional command inside an already-running container (commonly `docker exec -it <container> bash` for an interactive shell).

16. What is Kubernetes and what problem does it solve?

    Kubernetes (K8s) is an open-source container orchestration platform. It automates deployment, scaling, self-healing, load balancing, and management of containerized applications across a cluster of machines.

17. What is a Pod in Kubernetes?

    A Pod is the smallest deployable unit in Kubernetes — a group of one or more tightly coupled containers that share the same network namespace (one IP), storage volumes, and lifecycle. Containers in a Pod are always co-located and co-scheduled.

18. What are the main components of the Kubernetes control plane?

    The control plane includes the `kube-apiserver` (front-end API), `etcd` (distributed key-value store for cluster state), `kube-scheduler` (assigns Pods to nodes), and `kube-controller-manager` (runs controllers that reconcile desired vs. actual state).

19. What runs on a Kubernetes worker node?

    Each worker node runs the `kubelet` (agent that manages Pods and talks to the control plane), a container runtime (e.g., containerd), and `kube-proxy` (maintains network rules for Service routing).

20. What is a Kubernetes Deployment and what does it manage?

    A Deployment is a controller that declaratively manages a set of identical Pods via a ReplicaSet. It handles scaling, rolling updates, and rollbacks, continuously reconciling the actual state toward the declared desired number of replicas.

See more Server Management flashcards →

Planning Server Management for Back-end Web Developement

Server Management (Back-end Web Developement) FAQ