My progress
Menu

Cloud / DevOps Engineer · entry diagnostic

Cloud / DevOps Engineer: entry diagnostic

Ten questions on the core lessons this path builds on. It is for your own planning: it doesn't unlock anything, and it doesn't replace the final examination. Each explanation links to the core module to revisit if you got it wrong.

10 questions · for your own planning · it does not unlock anything and does not replace the final examination ·

1. A web server on a Linux machine is started with the setting "listen on 127.0.0.1:3000". It works when you open

Why each option is right or wrong

  • “Port 3000 is reserved for local use on every operating system” (Incorrect): Ports above 1023 can be used by any program; 3000 has no special status.
  • “The other computers need a newer browser to reach port 3000” (Incorrect): The browser isn't the issue; nothing is listening for outside connections.
  • “The firewall blocks every port number above 1000” (Incorrect): Firewalls block what they're configured to block; this one isn't the cause.
  • “127.0.0.1 accepts connections only from the same machine” is correct.

    The loopback address stays inside the computer. To accept connections from the network, a server listens on the machine's address or on 0.0.0.0.

    • Same idea later: localhost inside a container means that container (CD2).
    • Check: ss -ltnp shows which address a port is bound to.

📖 Revise: Module 4: Computer Networks

2. A developer committed a file containing a database password, then deleted the file in the next commit and pushed both. What's the

Why each option is right or wrong

  • “The password is gone, because the latest commit doesn't contain it” (Incorrect): Git keeps every earlier commit; the file is still in the history.
  • “Git encrypts deleted files, so only the author can read them” (Incorrect): Git stores file contents as they were, without encryption.
  • “GitHub removes passwords from pushed commits automatically” (Incorrect): Secret scanning may warn about known key formats, but the content stays in the history.
  • “The password is still in the history; it must be changed” is correct.

    Anyone with the repository can check out the first commit and read it. Removing it from history is possible but every clone may still have it.

    • First: change the password.
    • Prevent: .gitignore and generated secrets (CD2, CD3).

📖 Revise: Module 9: Introduction to Git

3. On a Linux server, ls -l deploy.key shows -rw-r--r--. A security check says the key's permissions are too open. Which command fixes

Why each option is right or wrong

  • “chmod 777 deploy.key, so every program can read it” (Incorrect): That gives everyone read, write and run permission, the opposite of what's needed.
  • “chown root deploy.key, so it belongs to the administrator” (Incorrect): Ownership alone doesn't stop others reading it while the "others" read bit is set.
  • “rm deploy.key, then copy it again from email” (Incorrect): Sending keys by email exposes them further.
  • “chmod 600 deploy.key, so only the owner can read and write” is correct.

    rw-r--r-- lets every user on the machine read the key. 600 removes access for the group and others.

    • Check: ls -l shows -rw-------.
    • Tools: SSH refuses private keys that others can read.

📖 Revise: Module 64: Linux Commands

4. In one terminal you run export APP_VERSION=1.2.0. In a second terminal, echo $APP_VERSION prints nothing. Why?

Why each option is right or wrong

  • “export only works for variables with lowercase names” (Incorrect): Names can be uppercase; that's the convention.
  • “The second terminal needs to be opened as the root user” (Incorrect): Root has its own environment too; it wouldn't see the value either.
  • “Variables take a few minutes to copy to other terminals” (Incorrect): They aren't copied between running shells.
  • “Variables belong to that shell and its programs” is correct.

    Each terminal runs its own shell with its own environment. A value exported in one isn't seen by another unless it's set there too, or in a startup file.

    • Later: containers get settings the same way, through their environment (CD2).
    • Check: env | grep APP_ in each terminal.

📖 Revise: Module 63: Introduction to Linux

5. A site runs nginx in front of a Node.js app. nginx listens on port 80 and passes requests to the app on port 3000. What is nginx doing here?

Why each option is right or wrong

  • “Running the app's JavaScript faster than Node.js can” (Incorrect): nginx doesn't run JavaScript; Node.js does.
  • “Storing the app's database so it answers quickly” (Incorrect): nginx doesn't store application data.
  • “Translating port numbers so the app can use port 80 directly” (Incorrect): The app still listens on 3000; nginx forwards to it.
  • “Acting as a reverse proxy that passes requests to the app” is correct.

    nginx receives requests from users and forwards them to the app, which can add TLS, load balancing, retries and caching in one place.

    • Later: RouteRani's load balancer is nginx doing this for several copies (CD2).
    • Setting: proxy_pass http://app:3000;.

📖 Revise: Module 66: Web Server Configuration

6. A team moves a website to a new server and changes its DNS A record. Some users still reach the old server for a few hours. What's the

Why each option is right or wrong

  • “DNS changes only take effect after the old server is switched off” (Incorrect): DNS doesn't know whether the old server is running.
  • “The new server must be registered with every internet provider” (Incorrect): Providers look records up; nothing needs registering with each of them.
  • “A records can only be changed once a day per domain” (Incorrect): There's no such limit on changes.
  • “Resolvers cached the old answer until its TTL ran out” is correct.

    Each DNS answer has a time-to-live. Resolvers reuse the cached answer until it expires, so changes spread gradually.

    • Tip: lower the TTL a day before a planned move.
    • Keep: the old server running until traffic stops.

📖 Revise: Module 67: Hosting Technologies

7. What's the relationship between a Docker image and a container?

Why each option is right or wrong

  • “They're two names for the same thing, used interchangeably” (Incorrect): They're related but different: one is a template, the other a running copy.
  • “A container is a compressed image stored in a registry” (Incorrect): Registries store images; containers run on a host.
  • “An image is a backup taken from a running container each night” (Incorrect): Images are built from Dockerfiles; they aren't nightly backups.
  • “A container is a running copy started from a read-only image” is correct.

    Many containers can start from one image. Each gets a thin writable layer that's thrown away when it's removed.

    • Commands: docker build makes images; docker run starts containers.
    • More in: CD1.

📖 Revise: Module 69: Docker

8. A team runs its tests by hand before each release, and sometimes forgets. What does continuous integration add?

Why each option is right or wrong

  • “It writes the missing tests automatically for every change” (Incorrect): CI runs the tests you have; it doesn't write them.
  • “It lets the team skip testing because the code is checked in production” (Incorrect): Finding bugs in production is what CI is meant to prevent.
  • “It deploys every change straight to users without any checks” (Incorrect): That's continuous deployment without checks, which is risky; CI is about the checks.
  • “Tests run automatically on every change, before it's merged” is correct.

    A pipeline runs the same checks for every change, so nobody has to remember, and problems show up while the change is small.

    • Plus: required checks can block merging until they pass.
    • More in: CD7.

📖 Revise: Module 71: CI/CD

9. An app's API key is written directly in its source code. Which is the better way to give the app its key?

Why each option is right or wrong

  • “Split the key into two halves in different source files” (Incorrect): Both halves are still in the code and its history.
  • “Encode it in base64 so it doesn't look like a key” (Incorrect): Base64 is reversible by anyone; it hides nothing.
  • “Keep it in the code, but make the repository private” (Incorrect): Everyone with repository access, now and later, can read it.
  • “Pass it in at run time from a secrets manager or the environment” is correct.

    The key stays out of the code and its history, can differ per environment, and can be changed without a new release.

    • Then: change the old key, since it was exposed.
    • More in: CD2 and CD6.

📖 Revise: Module 77: Encryption and Secrets

10. A booking service runs on a single server. Which change most improves its availability?

Why each option is right or wrong

  • “A faster processor in the same single server” (Incorrect): A faster server still takes the service down when it fails.
  • “Restarting the server every night to keep it fresh” (Incorrect): Nightly restarts cause short outages and don't protect against failures.
  • “A larger hard disk, so logs take longer to fill it” (Incorrect): Disk space prevents one problem, but the server is still a single point of failure.
  • “Two or more running copies behind a load balancer” is correct.

    Removing the single point of failure means one copy can fail or be replaced while the others serve.

    • Needs: stateless copies and health checks.
    • More in: CD2 and CD6.

📖 Revise: Module 96: Reliability Engineering

← PreviousPath guide
ProLearners Assist