At the present time, Kubernetes has become the industry standard for deploying applications. This is because it makes it easier to manage the deployments and provides high availability and scalability.
We use YAML or JSON files to manage deployments in Kubernetes. In a normal deployment, we’ll generally use several YAML files to specify the configurations we need to successfully deploy the application.
In order to be more organized, we can put the YAML files in directories that will help us quickly find the YAML files we are looking for. For example, we can have a directory for the YAML files responsible for the testing environment and another for the production environment.
In this tutorial, we’ll see how to apply all the configurations that are present in several YAML files that are located in one common directory with a single command. As a result, this will make it a lot easier to handle the deployments.
2. Files Located in a Single Directory
In this section, we will see how we can apply all the YAML files located in one directory.
Firstly, let’s create a directory and call it dir1:
$ mkdir dir1
Inside the directory, let’s create the following four files.
Name the first file mongo-configmap.yaml:
apiVersion: v1 kind: ConfigMap metadata: name: mongodb-configmap data: database_url: mongodb-service
This file contains the configurations needed for the backend application to connect to the database.
2.2. File Containing the Secrets
Then, the second file will be mongo-secret.yaml:
apiVersion: v1 kind: Secret metadata: name: mongodb-secret type: Opaque data: mongo-root-username: dXNlcm5hbWU= mongo-root-password: cGFzc3dvcmQ=
This file contains configurations similar to the ConfigMap but are secrets that should not be visible publicly, such as the username and password for the database.
2.3. Backend Application
The third file will be named mongo-express.yaml:
apiVersion: apps/v1 kind: Deployment metadata: name: mongo-express labels: app: mongo-express spec: replicas: 1 selector: matchLabels: app: mongo-express template: metadata: labels: app: mongo-express spec: containers: - name: mongo-express image: mongo-express ports: - containerPort: 8081 env: - name: ME_CONFIG_MONGODB_ADMINUSERNAME valueFrom: secretKeyRef: name: mongodb-secret key: mongo-root-username - name: ME_CONFIG_MONGODB_ADMINPASSWORD valueFrom: secretKeyRef: name: mongodb-secret key: mongo-root-password - name: ME_CONFIG_MONGODB_SERVER valueFrom: configMapKeyRef: name: mongodb-configmap key: database_url --- apiVersion: v1 kind: Service metadata: name: mongo-express-service spec: selector: app: mongo-express type: LoadBalancer ports: - protocol: TCP port: 8081 targetPort: 8081 nodePort: 30000
This is the deployment file for the backend application. It contains two parts. The first is the Deployment which is responsible for the configurations of the pods that will be containing the backend application.
At the same time, the second part is the Service which is responsible for exposing the application so that we can access it.
Finally, let’s create this file mongo.yaml and add the following text to it:
apiVersion: apps/v1 kind: Deployment metadata: name: mongodb-deployment labels: app: mongodb spec: replicas: 1 selector: matchLabels: app: mongodb template: metadata: labels: app: mongodb spec: containers: - name: mongodb image: mongo ports: - containerPort: 27017 env: - name: MONGO_INITDB_ROOT_USERNAME valueFrom: secretKeyRef: name: mongodb-secret key: mongo-root-username - name: MONGO_INITDB_ROOT_PASSWORD valueFrom: secretKeyRef: name: mongodb-secret key: mongo-root-password --- apiVersion: v1 kind: Service metadata: name: mongodb-service spec: selector: app: mongodb ports: - protocol: TCP port: 27017 targetPort: 27017
Similarly, like the previous file, this file contains a Deployment and a Service for the database that the backend will connect to.
2.5. Deploying All the Files at Once
After all the files were created, we now want to run a single command that will apply all the configurations in the four files.
We can do this by running the following:
$ kubectl apply -f <folder>
Now that everything is ready, let’s try it with our example. But in order for the command to run successfully, we need to make sure we are in the parent directory containing the directory we previously created. Then we can run kubectl:
$ kubectl apply -f dir1
When we do this, kubectl will recurse over each file in the directory, and if it is a YAML (or JSON) file, it will apply it.
To check the results, we can run the following:
$ kubectl get all NAME READY STATUS RESTARTS AGE pod/svclb-mongo-express-service-l8dxb 1/1 Running 0 6m45s pod/mongodb-deployment-8f6675bc5-gxfl9 1/1 Running 0 6m45s pod/mongo-express-78fcf796b8-nx94g 1/1 Running 1 (6m4s ago) 6m45s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.43.0.1 <none> 443/TCP 12d service/mongodb-service ClusterIP 10.43.238.212 <none> 27017/TCP 6m45s service/mongo-express-service LoadBalancer 10.43.108.110 172.19.0.3 8081:30000/TCP 6m45s NAME DESIRED CURRENT READY UP-TO-DATE AVAILABLE NODE SELECTOR AGE daemonset.apps/svclb-mongo-express-service 1 1 1 1 1 <none> 6m45s NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/mongodb-deployment 1/1 1 1 6m45s deployment.apps/mongo-express 1/1 1 1 6m45s NAME DESIRED CURRENT READY AGE replicaset.apps/mongodb-deployment-8f6675bc5 1 1 1 6m45s replicaset.apps/mongo-express-78fcf796b8 1 1 1 6m45s
So, we can see from the output of the command that all the Deployments and Services from our files were created successfully.
3. Files Located in Nested Directories
What we did in the previous section was useful, but how about if we want to organize our YAML files into several folders? Will we need to run the previous command on each one of these folders? The answer is no; there is an easier way.
Let’s first delete the Deployments and Services that we created in the previous section so that we can have a fresh start.
To delete the Deployments run this:
$ kubectl delete deploy mongodb-deployment mongo-express
To delete the Services, we can run the following:
$ kubectl delete service mongodb-service mongo-express-service
We can check they were deleted by running this command:
$ kubectl get all
Next, let’s move mongo-express.yaml and mongo.yaml to an apps folder. Also, let’s move the other two files to a folder called conf.
The folder tree should be similar to this:
dir1 ├── apps │ ├── mongo-express.yaml │ └── mongo.yaml └── conf ├── mongo-configmap.yaml └── mongo-secret.yaml
Now if we try to run the kubectl apply -f <folder> command again from the parent directory of dir1, we will get an error:
$ kubectl apply -f dir1 error: error reading [dir1]: recognized file extensions are [.json .yaml .yml]
This is because the command is looking for the YAML files in the dir1 directory, and there are none.
We need to tell it to search recursively inside the directory to find all the files. We can do this by adding the -R or —recursive options to our command.
Let’s try it again after adding -R:
$ kubectl apply -f dir1 -R
This time the command was successful, and the Deployments and Services were created.
In this article, we discussed many YAML files we use to manage our deployments. It is generally a good idea to organize them into multiple folders.