Chapter 3: Dictionaries (Maps)¶

In this chapter, we’ll focus on dictionaries, also known as maps in YAML. Dictionaries are essential in YAML as they allow you to represent key-value pairs, where the key is a string, and the value can be anything from a simple scalar to a complex structure like another dictionary or a list. This is especially useful in DevOps when defining configurations for services, resources, and infrastructure.

3.1 Basic Dictionary Syntax¶

A dictionary is a collection of key-value pairs, where each key is followed by a colon (:) and its corresponding value.

Example: Basic Dictionary¶

# Dictionary representing a web server configuration
server:
  name: nginx    # Key: name, Value: nginx
  port: 80       # Key: port, Value: 80
  ssl: true      # Key: ssl, Value: true

In this example: - server is a dictionary containing three key-value pairs: name, port, and ssl. - The keys are name, port, and ssl. - The values are a string (nginx), a number (80), and a boolean (true).

3.2 Nested Dictionaries¶

You can nest dictionaries inside other dictionaries to represent more complex structures.

Example: Nested Dictionary¶

# Web server configuration with nested dictionaries
server:
  name: nginx
  config:
    port: 80
    ssl: true
    root: /var/www/html

Here: - The server dictionary contains a nested dictionary config, which has its own key-value pairs (port, ssl, root). - This structure is common in DevOps when you need to group related configurations together.

3.3 Multi-Line Values in Dictionaries¶

YAML allows you to define long values that span multiple lines. This is helpful for representing long strings, configuration blocks, or scripts.

There are two ways to handle multi-line strings: - Literal Block Style (|): Preserves line breaks. - Folded Block Style (>): Folds newlines into spaces, unless there’s an empty line.

Example: Literal Block Style (`|`)¶

# Multi-line string using literal block style
server:
  name: nginx
  config:
    description: |
      This is a web server
      used to host the application.
      It supports multiple domains.

Example: Folded Block Style (`>`)¶

# Multi-line string using folded block style
server:
  name: nginx
  config:
    description: >
      This is a web server
      used to host the application.
      It supports multiple domains.

Here, the string will be folded into a single line:

This is a web server used to host the application. It supports multiple domains.

3.4 Inline Dictionaries¶

You can represent a dictionary in a compact form on a single line using curly braces {}.

Example: Inline Dictionary¶

# Inline dictionary for server details
server: { name: nginx, port: 80, ssl: true }

This format is more compact but can become difficult to read for larger structures. It’s mostly useful for simple configurations or when saving space is critical.

3.5 Lists of Dictionaries¶

YAML allows you to combine dictionaries with lists, making it easy to represent collections of related key-value pairs.

Example: List of Dictionaries¶

# A list of dictionaries representing different servers
servers:
  - name: nginx
    port: 80
    ssl: true
  - name: apache
    port: 8080
    ssl: false

Here: - The servers key contains a list of dictionaries. - Each dictionary contains key-value pairs representing the properties of a server. - This is a very common structure in DevOps, where you may have multiple services or servers to configure.

3.6 Best Practices for Dictionaries¶

Consistency in Key Naming: Stick to a consistent naming convention for keys, such as all lowercase with hyphens (-) or underscores (_).
Use Nested Dictionaries Wisely: Avoid over-nesting, as it can make the YAML file harder to read. If a dictionary becomes too complex, consider refactoring it into a separate YAML file.
Quotes Around Special Characters: If a key or value contains special characters like : or #, enclose them in quotes.

Example:¶

# Use quotes around special characters
service:
  name: "nginx-service"
  path: "/usr/local/bin"

Multi-Line Comments: Use comments to explain complex dictionaries, especially when they involve nested structures.

Example with Comments:¶

# Web server configuration
server:
  name: nginx    # The name of the web server
  config:
    port: 80     # The port for HTTP traffic
    ssl: true    # Enable SSL for HTTPS
    root: /var/www/html  # The root directory for serving files

3.7 Real-World Use Cases of Dictionaries in DevOps¶

Kubernetes Service Definition¶

Define a Kubernetes Service using a dictionary with multiple key-value pairs.

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376

The spec dictionary defines the service’s behavior, including a selector and a list of ports.

Ansible Playbooks¶

Dictionaries are used to define tasks and modules in Ansible playbooks.

- hosts: webservers
  tasks:
    - name: Install nginx
      yum:
        name: nginx
        state: present

The tasks key contains a dictionary that defines the module (yum) and its associated parameters (name and state).

3.8 Practice Exercise: Writing a Dictionary in YAML¶

Try writing a YAML configuration for defining a database server with multiple key-value pairs, including a nested dictionary for its connection settings.

# Database server configuration
database:
  name: postgres
  version: 13
  connection:
    host: 127.0.0.1
    port: 5432
    ssl: true
  users:
    - name: admin
      role: superuser
    - name: guest
      role: read-only

This concludes Chapter 4 on Dictionaries (Maps). You should now be comfortable creating dictionaries, nesting them, and combining them with lists. These skills are fundamental to configuring complex systems in DevOps tools.