Introduction to YAML for Kubernetes
Tags: devops, kubernetes, cloud, tutorial
Published: 2023-12-16 21:47:52


Welcome as we go through the basics of YAML, the go-to configuration language for Kubernetes. No tech jargon or complex terms here, just straightforward insights to help you understand  YAML. 
In this article, we will check out YAML as it pertains to Kubernetes. 

## YAML?

YAML, short for YAML Ain’t Markup Language, is a file format for making configurations. It is a data serialization language for all programming languages, which means it acts as a middleman to let programming languages talk to each other. Although Kubernetes files can be written in JSON and XML, YAML is the most preferred for this. 
Among the benefits of YAML are:

- Human readable
- Intuitive Structure
- Easy to Learn and Write
- Versatility in Configuration

##Assumptions:
I assume that you:
- Know what Kubernetes is
- Know what Kubernetes config files are.

If you know the above, let's jump right into it.

## Understanding YAML

It will be nice to get some understanding of YAML.
Let's start with indentation.

### **Indentation**

YAML uses indentation to represent the structure of data. Think of it like an organized to-do list. Each task (or data element) is neatly indented to show its relationship to the broader category. Indentation signifies the hierarchy and relationship between different components in a YAML file.
Notice how in the first countries list, the countries are all aligned, while in the second countries list the fact that the countries are not all aligned makes it invalid YAML.
YAML takes indentation very seriously.

```yaml
#valid yaml
countries:
  -Nigeria
  -India
  -USA
  -Germany

#invalid yaml
countries:
  -Nigeria
-India
  -USA
  -Germany
```
### **Key-Value Pairs**

It uses a key-value pair structure. Let's look at how this key-value setup works.


```yaml
name: Otuekong
```
In the above example, the colon separates the key from the value, with the name being the key and `Otuekong` being the value.

### **Sequence/Lists**

Sequence/List offers a way to group related data in YAML.

```yaml
countries:
  -Nigeria
  -India
  -USA
  -Germany
```
In the above example, the `countries` key has a list of strings representing different countries.

The above may also be written as:

```yaml
countries: [Nigeria, India, USA, Germany]
```

There are nested lists too in YAML. See it as a list inside a list or lists inside a list.

```yaml
nested_list:
  - list1
  - list2:
      -sublist1
      -sublist2
```
In the preceding example, the `nested_list` key has `list1` and `list2` under it.`list2` holds `sublist1` and `sublist2` 

### **Scalars**

A scalar is a single piece of information, such as a number or some text. It's like a basic building block for data, like a single Lego piece instead of the whole Lego set. Scalars in YAML are simple, just like writing a single number or a short sentence. They help you express simple stuff without getting too fancy or complicated.
There are 4 scalar types in YAML:
- Strings
- Numbers
- Booleans
- Null

Let’s go a little deeper into the scalar types.
**Strings**
Unlike Javascript-Object Notation(JSON), Yaml accepts strings with or without quotation marks.

```yaml

name: Hector #string without quotation marks

name2: 'Hector' #string with quotation marks
```
The above demonstrates the two ways of declaring a string in YAML and they are both valid.

**Numbers**
When it comes to numbers, it can be represented in YAML as:
- Integers
- Floating-point numbers
- Scientific notation (exponential notation)
- Hexadecimal and octal notation (using `0x` and `0o` prefixes)
- Numeric strings

```yaml
age: 50 #I am an integer
temperature: 23.5 #I am a floating-point
large_number: 4.022e23 #I am a scientific notation
hex_value: 0xFF #I am a hex value
octal_value: 0o12 #I am an octal value
numeric_string: "007" #I am a numeric string
```



**Booleans**
In YAML, on, true, and yes represent true while off, false, and no represent false.

```yaml
#These are all true values
christmas: on
harmattan: true 
holiday: yes 

#These are all falsy values
rains: off
travel: false
something: no
```

**Null**
Null represents the absence of a value. It can be represented with the string `null` or the tilde sign (~) which on most keyboards is located on the top-left corner of the keyboard, to the left of the number 1 key.

```yaml
christmasHamper: null 
reason: ~
```
The above snippet demonstrates the usage of null.

### Maps
A map is like a dictionary where you have a key (the word) and a value (the definition). Maps in YAML help organize data in a clear and easy-to-read way.
The snippet below represents a simple map under the key scores. Each entry within the scores map consists of a name (key) and a corresponding score (value).

```yaml
scores:
  Williams: 45
  Francis: 13
  Charles: 65
```

### **Comments**
Comments are like little notes you can add to explain things. You put a # (hash symbol) and then write whatever you want next to it. YAML ignores it as it's just for you and others to understand what's going on.

```yaml
desserts:
  - Cupcakes #This is a comment
  - Chocolate Chip Cookies
  - Brownies

#This is also a comment
```

## YAML in Kubernetes
It is possible to imperatively manage Kubernetes resources by directly giving Kubernetes the instructions to manage your resources but soon enough this will get tiring and complicated to manage. Then comes the declarative way. Using YAML configuration files. With this, you just write what you want Kubernetes to do in a YAML file, point Kubernetes to the file, and let it handle the rest. Let's relate what we learned up there to Kubernetes.
We will need a Kubernetes config file. For this, let's go with a Pod file:

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: merry_christmas
spec:
  containers:
  - name: nginx-container
    image: nginx:stable-alpine-slim
    ports:
    - containerPort: 80
  restartPolicy: Always
  nodeSelector:
    gpu: true
	  activeDeadlineSeconds: null
```

Let’s break down the content of the above file.

1. **apiVersion**: This is a string scalar that Specifies the Kubernetes API version used.
2. **kind**: This is still another string scalar that Indicates the type of Kubernetes resource in this case Pod.
3. **metadata**: It is a map that Contains metadata about the Pod. In this case, It contains the name of the pod.
4. **spec**: This is a map that Describes the desired state of the Pod. This contains a map of:
5. **containers**: Specifies a list of containers within the Pod.
6. **name**: This is a string scalar inside containers stating the name of the container. 
7. image: This is also a  string scalar inside containers specifying the Docker image to use.
8.ports: This contains a list of ports for the container.
9.containerPort: This is a scalar integer and indicates to Kubernetes the port to open on the container in this case port 80. 
10. **restartPolicy**: It is a  string scalar that sets the restart policy for the Pod.
11. **nodeSelector**: This is a map that specifies node selection criteria for the Pod.
12. **gpu**: This is a  boolean scalar indicating whether the node should have a ***graphics processing unit***(GPU). Here it is set to true. It could also take yes.
13. **activeDeadlineSeconds**: Specifies the maximum time (in seconds) for the Pod to run. It's set to **`null` scalar**, indicating an undefined value.

Three things are worthy of note here. They are:

- scalars represent single values which could be numbers, strings, booleans, and null.
- Mappings represent key-value pairs.
- Sequences represent lists of items.

Understand the above and throw in indentation and you are on your way to conquer YAML.

## Conclusion

Understanding YAML  is essential for anyone working with Kubernetes. In this article, we went into the basics of YAML, looking at indentation, scalars, maps, and sequences. We finally connected the dots and made sense of the pieces that make up YAML. I hope this article made YAML more approachable and in a way simplified your Kubernetes operations.
Thanks.

### Resource
If you are looking to advance your understanding of YAML, I recommend this article.
[YAML Tutorial: A Complete Language Guide with Examples](https://spacelift.io/blog/yaml)