Configuration management in Deno - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is configuration management in software development?

Configuration management is the process of handling and organizing settings and options that control how software behaves. It helps keep track of changes and ensures consistent setups across environments.

beginner

How does Deno typically manage configuration settings?

Deno manages configuration by using environment variables, JSON or YAML files, and sometimes command-line arguments. It encourages secure and simple ways to load settings without extra dependencies.

beginner

Why is it important to separate configuration from code?

Separating configuration from code allows you to change settings like database URLs or API keys without changing the program itself. This makes your app flexible and safer, especially when moving between development and production.

beginner

What is the role of environment variables in configuration management?

Environment variables store configuration values outside the code, like passwords or ports. They keep sensitive data safe and let you easily switch settings depending on where your app runs.

intermediate

How can you load a JSON configuration file in Deno?

You can load a JSON config file in Deno using the built-in 'Deno.readTextFileSync' to read the file, then 'JSON.parse' to convert it into a JavaScript object for use in your app.

Which method is NOT commonly used for configuration management in Deno?

A Environment variables

B JSON configuration files

C Hardcoding values directly in code

D YAML configuration files

Hardcoding values directly in code is discouraged because it makes changing settings harder and less secure.

What is a key benefit of using environment variables for configuration?

A They make the code run faster

B They keep sensitive data out of the codebase

C They automatically update the code

D They replace the need for configuration files

Environment variables keep sensitive data like passwords separate from code, improving security.

In Deno, which function reads a file's content as text?

A Deno.loadFile

B Deno.readFileSync

C Deno.openFile

D Deno.readTextFile

Deno.readTextFile reads the entire file content as a string, useful for reading config files.

Why should configuration be separated from application code?

A To allow easy changes without modifying code

B To make the code longer

C To reduce the number of files

D To make the app slower

Separating configuration allows changing settings without touching the code, making maintenance easier.

Which file format is NOT commonly used for configuration in Deno projects?

A XML

B YAML

C ENV

D JSON

XML is rarely used for configuration in Deno; JSON, YAML, and ENV files are more common.

Explain how you would manage configuration in a Deno application to keep sensitive data safe and allow easy changes.

Think about separating secrets from code and how to read files in Deno.

Describe why separating configuration from code is a good practice and how it helps when moving an app from development to production.

Consider what changes between environments and how to handle them safely.

Practice

1. What is the main purpose of configuration management in a Deno application?

easy

A. To separate settings like API keys from the main code for flexibility and security

B. To write all code and settings in a single file for simplicity

C. To hardcode secret keys directly in the source code

D. To avoid using environment variables altogether

Solution

1. Step 1: Understand configuration management role

   Configuration management separates settings from code to keep apps flexible and secure.

2. Step 2: Identify correct practice in Deno

   Using environment variables or .env files keeps secrets out of code and allows easy changes.

3. Final Answer:

   To separate settings like API keys from the main code for flexibility and security -> Option A

4. Quick Check:

   Config management = separate settings [OK]

Hint: Remember: keep secrets out of code, use config files [OK]

Common Mistakes:

• Hardcoding secrets in source code
• Mixing code and settings in one file
• Ignoring environment-specific configs

2. Which of the following is the correct way to load environment variables from a .env file in Deno?

easy

A. require('dotenv').config();

B. import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config();

C. import dotenv from "dotenv"; dotenv.load();

D. import { loadEnv } from "deno_env"; loadEnv();

Solution

1. Step 1: Identify Deno's dotenv import syntax

   Deno uses ES module imports from URLs, like importing config from std/dotenv.

2. Step 2: Check correct usage

   Calling config() loads environment variables from .env file correctly in Deno.

3. Final Answer:

   import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config(); -> Option B

4. Quick Check:

   Deno dotenv import = import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config(); [OK]

Hint: Use Deno's std/dotenv with ES module import [OK]

Common Mistakes:

• Using Node.js require syntax in Deno
• Using non-existent packages
• Calling wrong functions to load env

3. Given this Deno code snippet:

import { config } from "https://deno.land/std/dotenv/mod.ts";
const env = config();
console.log(env.API_KEY);

If the .env file contains API_KEY=12345, what will be printed?

medium

A. undefined

B. Error: .env file not found

C. API_KEY

D. 12345

Solution

1. Step 1: Understand config() output

   The config() function reads .env and returns an object with keys and values.

2. Step 2: Access API_KEY value

   env.API_KEY accesses the value '12345' from the loaded environment variables.

3. Final Answer:

   12345 -> Option D

4. Quick Check:

   env.API_KEY = '12345' [OK]

Hint: config() returns env vars as object keys [OK]

Common Mistakes:

• Expecting config() to print keys directly
• Forgetting to create .env file
• Assuming env variables are undefined

4. What is wrong with this Deno code snippet for loading environment variables?

import { config } from "https://deno.land/std/dotenv/mod.ts";
const env = config;
console.log(env.API_SECRET);

medium

A. config is not imported correctly

B. API_SECRET is not a valid environment variable name

C. config is assigned without calling it as a function

D. console.log syntax is incorrect

Solution

1. Step 1: Check how config is used

   config is a function and must be called with parentheses to load env variables.

2. Step 2: Identify the error

   Assigning config without () means env is the function itself, not the loaded object.

3. Final Answer:

   config is assigned without calling it as a function -> Option C

4. Quick Check:

   Call config() to load env [OK]

Hint: Always call config() with parentheses [OK]

Common Mistakes:

• Assigning function reference instead of calling it
• Misspelling config import
• Using wrong variable names

5. You want to manage different configurations for development and production in a Deno app. Which approach is best practice?

hard

A. Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable

B. Hardcode production secrets in the code and use .env only for development

C. Use a single .env file with all keys and comment out unused ones manually

D. Store all secrets in a JSON file checked into version control

Solution

1. Step 1: Understand environment-specific configs

   Different environments need different settings to avoid mistakes and leaks.

2. Step 2: Choose best practice for Deno

   Using separate .env files and loading based on an environment variable keeps configs clean and secure.

3. Final Answer:

   Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable -> Option A

4. Quick Check:

   Separate env files per environment = Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable [OK]

Hint: Use multiple .env files and switch by env variable [OK]

Common Mistakes:

• Hardcoding secrets in code
• Using one .env for all environments
• Checking secrets into version control