1. Introduction

In this tutorial, we will explore how to use Docker and Kubernetes for deploying your GraphQL API. The goal is to understand the process of setting up Docker containers, orchestrating them with Kubernetes, and managing your deployment effectively.

You'll learn:
- How to use Docker & Kubernetes
- How to set up Docker containers
- How to orchestrate Docker containers with Kubernetes
- How to manage your deployment

Prerequisites:
- Basic knowledge of Docker & Kubernetes
- Basic understanding of GraphQL
- Installed Docker & Kubernetes

2. Step-by-Step Guide

Docker

Docker is an open-source platform that automates deploying, scaling, and managing applications inside containers.

First, create a Dockerfile in your project root directory. This file will specify how Docker should build your image.

FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 4000
CMD [ "node", "server.js" ]

This Dockerfile is doing several things:
- FROM node:14 is setting the base image to node:14
- WORKDIR /usr/src/app sets the working directory inside the container
- COPY package*.json ./ copies both package.json and package-lock.json to the Docker image
- RUN npm install installs our project dependencies
- COPY . . copies the rest of our files
- EXPOSE 4000 tells Docker to listen on port 4000
- CMD [ "node", "server.js" ] starts our application

Build your Docker image using the docker build command:

$ docker build -t my-api .

Now, you can run your Docker image using the docker run command:

$ docker run -p 4000:4000 -d my-api

Kubernetes

Kubernetes is a container orchestration platform for automating application deployment, scaling, and management.

Create a deployment.yaml file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-api
  template:
    metadata:
      labels:
        app: my-api
    spec:
      containers:
      - name: my-api
        image: my-api
        ports:
        - containerPort: 4000

This file tells Kubernetes to run 3 replicas of your Docker image, and that it should expose port 4000.

Use the kubectl apply command to create the deployment:

$ kubectl apply -f deployment.yaml

3. Summary

In this tutorial, we have learned how to use Docker and Kubernetes for deploying a GraphQL API. We started with setting up Docker containers, then moved on to orchestrating these containers with Kubernetes.

4. Practice Exercises

1. Create a Dockerfile for a different Node.js application and build the Docker image.
2. Create a Kubernetes deployment for the Docker image from exercise 1 and expose a different port.
3. Scale the number of replicas in your Kubernetes deployment to 5.

5. Additional Resources

• Docker Documentation
• Kubernetes Documentation
• GraphQL Documentation