Docker deployment for Deno - Mini Project: Build & Apply

Docker deployment for Deno

📖 Scenario: You want to run a simple Deno web server inside a Docker container. This helps you share your app easily and run it anywhere without setup problems.

🎯 Goal: Build a Docker setup that runs a Deno server. The server will respond with a greeting message when you visit it in a browser.

📋 What You'll Learn

Create a Deno server script named server.ts that listens on port 8000 and responds with 'Hello from Deno!'

Create a Dockerfile that uses the official Deno image

Configure the Dockerfile to copy the server script and run it with the right permissions

Expose port 8000 in the Dockerfile so the server is reachable

💡 Why This Matters

🌍 Real World

Deploying Deno apps in Docker containers is common for easy sharing, scaling, and running apps in cloud or local environments.

💼 Career

Many companies use containerization with Docker to deploy backend services. Knowing how to package Deno apps in Docker is a valuable skill for modern web developers and DevOps roles.

1

Create the Deno server script

Create a file named server.ts with a Deno HTTP server that listens on port 8000 and responds with the text 'Hello from Deno!'. Use the serve function from https://deno.land/std@0.177.0/http/server.ts.

Deno

# Your code here to create server.ts with a Deno HTTP server

Hint

Use the serve function from Deno's standard library to create a simple HTTP server.

2

Start the Dockerfile with the Deno base image

Create a Dockerfile that starts with the official Deno image denoland/deno:alpine-1.34.3. Set the working directory inside the container to /app.

Deno

# Your code here to start Dockerfile with base image and working directory

Hint

Use FROM to pick the Deno image and WORKDIR to set the folder inside the container.

3

Copy the server script and set permissions

In the Dockerfile, copy the server.ts file into the container's /app folder. Then add a command to run the server with deno run --allow-net server.ts.

Deno

# Your code here to copy server.ts and set the run command

Hint

Use COPY to add files and CMD to set the default command.

4

Expose port 8000 in the Dockerfile

Add a line in the Dockerfile to expose port 8000 so Docker knows which port the app uses.

Deno

# Your code here to expose port 8000

Hint

Use the EXPOSE instruction to tell Docker which port the container listens on.

Practice

1. What is the main purpose of using Docker for deploying a Deno application?

easy

A. To replace the Deno runtime

B. To write Deno code faster

C. To package the app so it runs the same on any machine

D. To debug Deno code inside the browser

Solution

1. Step 1: Understand Docker's role

   Docker packages apps with all dependencies so they run consistently anywhere.

2. Step 2: Relate to Deno deployment

   Using Docker for Deno ensures the app runs the same on any machine without setup issues.

3. Final Answer:

   To package the app so it runs the same on any machine -> Option C

4. Quick Check:

   Docker packages apps = To package the app so it runs the same on any machine [OK]

Hint: Docker ensures consistent app environment everywhere [OK]

Common Mistakes:

• Thinking Docker speeds up coding
• Confusing Docker with Deno runtime
• Assuming Docker is for debugging only

2. Which Dockerfile instruction correctly sets the command to run a Deno script named app.ts with all permissions?

easy

A. CMD ["deno", "run", "--allow-all", "app.ts"]

B. RUN deno run --allow-all app.ts

C. ENTRYPOINT deno app.ts

D. CMD deno start app.ts

Solution

1. Step 1: Identify correct Dockerfile command syntax

   CMD with JSON array syntax is preferred for commands with arguments.

2. Step 2: Match Deno run command with permissions

   "deno run --allow-all app.ts" runs the script with all permissions; CMD array syntax is correct.

3. Final Answer:

   CMD ["deno", "run", "--allow-all", "app.ts"] -> Option A

4. Quick Check:

   Use CMD with JSON array for run command [OK]

Hint: Use CMD with JSON array for Deno run commands [OK]

Common Mistakes:

• Using RUN instead of CMD for runtime command
• Omitting --allow-all permission flag
• Using ENTRYPOINT without arguments array

3. Given this Dockerfile snippet:

FROM denoland/deno:latest
WORKDIR /app
COPY . .
RUN deno cache app.ts
CMD ["deno", "run", "--allow-net", "app.ts"]

What happens when you build and run this container?

medium

A. The app runs with network access allowed

B. The app runs but without network access

C. The container build fails due to missing permissions

D. The app runs but caching is skipped

Solution

1. Step 1: Analyze Dockerfile commands

   The Dockerfile caches dependencies with "deno cache app.ts" and runs the app with "--allow-net" permission.

2. Step 2: Understand runtime behavior

   CMD runs the app allowing network access, so the app can use network features.

3. Final Answer:

   The app runs with network access allowed -> Option A

4. Quick Check:

   --allow-net enables network access = The app runs with network access allowed [OK]

Hint: Check permission flags in CMD to know app access [OK]

Common Mistakes:

• Confusing cache step with runtime permissions
• Assuming build fails without --allow-all
• Ignoring the effect of --allow-net flag

4. You wrote this Dockerfile:

FROM denoland/deno:latest
WORKDIR /app
COPY . .
CMD ["deno", "run", "app.ts"]

But when running the container, the app crashes with permission errors. What is the fix?

medium

A. Remove COPY command

B. Change WORKDIR to /usr/src/app

C. Use RUN instead of CMD for deno run

D. Add permission flags like --allow-net to the CMD

Solution

1. Step 1: Identify cause of permission errors

   Deno requires explicit permission flags to access resources like network or file system.

2. Step 2: Fix Dockerfile CMD to include permissions

   Add flags like --allow-net or --allow-read to CMD so app has needed permissions at runtime.

3. Final Answer:

   Add permission flags like --allow-net to the CMD -> Option D

4. Quick Check:

   Permission errors need flags in CMD [OK]

Hint: Add needed --allow-* flags to CMD to fix permission errors [OK]

Common Mistakes:

• Changing WORKDIR without cause
• Removing COPY which copies app files
• Using RUN instead of CMD for runtime command

5. You want to optimize your Deno Docker image by caching dependencies to speed up builds. Which Dockerfile sequence achieves this best?

hard

A. COPY . .
RUN deno cache app.ts
CMD ["deno", "run", "--allow-all", "app.ts"]

B. COPY deps.ts ./
RUN deno cache deps.ts
COPY . .
CMD ["deno", "run", "--allow-all", "app.ts"]

C. RUN deno cache app.ts
COPY . .
CMD ["deno", "run", "app.ts"]

D. COPY app.ts ./
CMD ["deno", "run", "app.ts"]

Solution

1. Step 1: Understand Docker layer caching

   Docker caches layers; caching dependencies separately avoids re-downloading on code changes.

2. Step 2: Analyze COPY deps.ts ./ RUN deno cache deps.ts COPY . . CMD ["deno", "run", "--allow-all", "app.ts"]

   Copying only deps.ts and caching it first means dependencies are cached unless deps.ts changes, then copying rest avoids rebuilding cache.

3. Step 3: Compare other options

   Options A and C copy all files before caching, so cache invalidates on any file change; D lacks caching step.

4. Final Answer:

   COPY deps.ts ./ RUN deno cache deps.ts COPY . . CMD ["deno", "run", "--allow-all", "app.ts"] -> Option B

5. Quick Check:

   Cache deps separately for faster rebuilds [OK]

Hint: Cache dependencies before copying app code to speed builds [OK]

Common Mistakes:

• Copying all files before caching dependencies
• Skipping deno cache step
• Not using permission flags in CMD