Deploy drawio to kubernetes

Okay, here’s how you can deploy a draw.io Docker container to a Kubernetes cluster. I’ll provide a step-by-step guide with explanations. This uses a simple example. You may need to adjust resource requests/limits and other configurations depending on your needs.

1. Prerequisites:

• A Kubernetes Cluster: You need a running Kubernetes cluster. This could be Minikube, Kind, a cloud provider’s Kubernetes service (GKE, EKS, AKS), or a self-managed cluster.
• kubectl: The kubectl command-line tool configured to connect to your cluster.
• Docker Image: We’ll use the official draw.io Docker image: jgraph/drawio.

2. Create Kubernetes Deployment and Service YAML Files:

Create two YAML files: drawio-deployment.yaml for the deployment and drawio-service.yaml for the service.

drawio-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: drawio-deployment
  labels:
    app: drawio
spec:
  replicas: 1  # Start with one replica. Adjust as needed.
  selector:
    matchLabels:
      app: drawio
  template:
    metadata:
      labels:
        app: drawio
    spec:
      containers:
      - name: drawio
        image: jgraph/drawio:latest #  Use the latest drawio image
        ports:
        - containerPort: 8080  # Default port draw.io runs on
        resources:
          requests:
            cpu: 100m  # Request 100 millicores (0.1 CPU)
            memory: 256Mi # Request 256 MB of memory
          limits:
            cpu: 500m  # Limit to 500 millicores (0.5 CPU)
            memory: 512Mi # Limit to 512 MB of memory

Explanation:

• apiVersion: apps/v1: Specifies the Kubernetes API version for deployments.
• kind: Deployment: Defines this as a deployment object.
• metadata.name: The name of the deployment.
• metadata.labels: Labels to identify this deployment.
• spec.replicas: The number of pods to run. Adjust this if you need more instances for higher availability.
• spec.selector: A label selector that matches the labels on the pods created by this deployment. This tells the deployment which pods it manages.
• spec.template: Defines the pod template.
  • spec.template.metadata.labels: Labels that will be applied to the pods created by this deployment.
  • spec.template.spec.containers: A list of containers to run in the pod.
    • name: The name of the container.
    • image: The Docker image to use. We’re using jgraph/drawio:latest. Consider using a specific version tag for stability in production (jgraph/drawio:21.6.0 for example). “latest” is generally discouraged in production.
    • ports: Specifies the port the container exposes. draw.io runs on port 8080 by default.
    • resources: Specifies the resources (CPU and memory) that the container needs. Adjust these based on your expected usage. The requests value tells Kubernetes how much resources the pod needs and the limits value is the maximum that the pod is allowed to consume.

drawio-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: drawio-service
spec:
  selector:
    app: drawio
  ports:
  - protocol: TCP
    port: 80  # The port the service listens on
    targetPort: 8080 # The port the container exposes
  type: LoadBalancer  # Exposes the service externally (if supported)
  # type: ClusterIP  # (Alternative: Internal access only)
  # type: NodePort   # (Alternative: Exposes on node ports)

Explanation:

• apiVersion: v1: Specifies the Kubernetes API version for services.
• kind: Service: Defines this as a service object.
• metadata.name: The name of the service.
• spec.selector: A label selector that matches the labels on the pods that this service will route traffic to. In this case, it selects pods with the label app: drawio.
• spec.ports: Defines the ports that the service will listen on and forward traffic to.
  • protocol: The protocol to use (TCP).
  • port: The port the service will listen on. We’re using port 80 (standard HTTP).
  • targetPort: The port on the container that the service will forward traffic to (8080 in this case).
• spec.type: Determines how the service is exposed.
  • LoadBalancer: Creates a load balancer in your cloud provider (if supported) to expose the service externally. This is the simplest option for external access. If running on Minikube or Kind you may need to explicitly enable the LoadBalancer addon first.
  • ClusterIP: Creates an internal service only accessible within the cluster.
  • NodePort: Exposes the service on a specific port on each node in the cluster. You can then access the service using the node’s IP address and the chosen port.

3. Deploy to Kubernetes:

Use kubectl to apply the YAML files:

kubectl apply -f drawio-deployment.yaml
kubectl apply -f drawio-service.yaml

4. Verify the Deployment:

Check the status of the deployment and service:

kubectl get deployments
kubectl get services
kubectl get pods -l app=drawio # Lists pods matching the label `app=drawio`

5. Access draw.io:

• LoadBalancer: If you used type: LoadBalancer, Kubernetes will provision a load balancer (if supported by your environment). Get the external IP address or hostname of the load balancer:

  kubectl get service drawio-service -o wide
  

  Look for the EXTERNAL-IP field. Access draw.io in your browser using that IP address (or hostname). It may take a few minutes for the load balancer to be provisioned.

• ClusterIP: If you used type: ClusterIP, you’ll need to use port forwarding to access draw.io from your local machine:

  kubectl port-forward service/drawio-service 8080:80
  

  Then, access draw.io in your browser at http://localhost:8080. This is useful for testing. For persistent access you’d typically use an Ingress.

• NodePort: If you used type: NodePort, find the node’s external IP address and the NodePort that was assigned.

  kubectl get service drawio-service -o wide
  

  Look for the PORT(S) field. It will look like 80:30001/TCP. The 30001 part is your NodePort. Access draw.io in your browser using http://<node-ip>:<node-port>.

Important Considerations:

• Persistence: This configuration does not persist your diagrams. If the pod is restarted, your data will be lost. To persist data, you’ll need to configure a persistent volume and persistent volume claim. The draw.io docker image needs to have a volume mounted at /usr/share/nginx/html/storage to persist diagrams.

  # Example of Persistent Volume Claim (PVC)
  apiVersion: v1
  kind: PersistentVolumeClaim
  metadata:
    name: drawio-pvc
  spec:
    accessModes:
      - ReadWriteOnce  # Or ReadWriteMany if your storage supports it
    resources:
      requests:
        storage: 1Gi # Adjust as needed
  
  # And then, in your deployment, mount the PVC:
  
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: drawio-deployment
    labels:
      app: drawio
  spec:
    replicas: 1
    selector:
      matchLabels:
        app: drawio
    template:
      metadata:
        labels:
          app: drawio
      spec:
        containers:
        - name: drawio
          image: jgraph/drawio:latest
          ports:
          - containerPort: 8080
          volumeMounts:
          - name: drawio-storage
            mountPath: /usr/share/nginx/html/storage
        volumes:
        - name: drawio-storage
          persistentVolumeClaim:
            claimName: drawio-pvc # Reference the PVC
  
  

  Remember to create the PersistentVolume (PV) if you don’t have dynamic provisioning.

• Security: Consider using HTTPS for secure access. You can use an Ingress controller with TLS termination.

• Ingress: For more advanced routing and features like TLS termination, you should use an Ingress controller (e.g., Nginx Ingress Controller, Traefik). This is generally preferable to using a LoadBalancer service directly.

• Resource Limits: Adjust the CPU and memory requests and limits based on your needs and available resources. Start with small values and increase them if necessary.

• Monitoring: Monitor your draw.io deployment using Kubernetes monitoring tools (e.g., Prometheus, Grafana) to track performance and identify any issues.

• Namespaces: Consider deploying draw.io in a separate namespace for better organization and isolation.

• Updating: To update to a new version of draw.io, change the image tag in your drawio-deployment.yaml file and apply the changes with kubectl apply -f drawio-deployment.yaml. Kubernetes will handle the rolling update for you.

• Configuration: The Draw.io Docker container can be configured with environment variables. See the official documentation for available options: https://github.com/jgraph/drawio

This provides a basic working deployment. You’ll likely need to adapt it to your specific environment and requirements. Remember to test thoroughly.