JS7 JobScheduler

Space shortcuts

Page tree

Introduction

  • JS7 can be set up from a Helm Chart. Using the Linux-based JS7 container images which ship with a current Alpine base image and OpenJDK.
  • Users deploy JS7 products by creating a Kubernetes deployment object from a deployment YAML file.
    • For this purpose, users have to first install and set up the Kubernetes Cluster see JS7 - How to install a Kubernetes Cluster.
    • With the Helm Chart being up and running users can use values YAML files to deploy JS7 products.

Deployment Files

The YAML sample files for deployment to Kubernetes using Helm are attached to the article.

Download the archive file: buildachart_js7_working.zip

The archive includes the following files.

Deployment of JS7 Products: js7-deployment.yaml

js7-deplotment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "buildachart.fullname" . }}
  labels:
    {{- include "buildachart.labels" . | nindent 4 }}
spec:
  {{- if not .Values.autoscaling.enabled }}
  replicas: {{ .Values.replicaCount }}
  {{- end }}
  selector:
    matchLabels:
      {{- include "buildachart.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      {{- with .Values.podAnnotations }}
      annotations:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      labels:
        {{- include "buildachart.selectorLabels" . | nindent 8 }}
    spec:
      {{- with .Values.imagePullSecrets }}
      imagePullSecrets:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      serviceAccountName: {{ include "buildachart.serviceAccountName" . }}
      securityContext:
        {{- toYaml .Values.podSecurityContext | nindent 8 }}
      volumes:
        - name: hibernate-config
          configMap:
            name: hibernate-config
      containers:
        - name: {{ .Chart.Name }}
          securityContext:
            {{- toYaml .Values.securityContext | nindent 12 }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: {{ .Values.service.port }}
              protocol: TCP
          volumeMounts:
            - name: hibernate-config
              mountPath: /var/sos-berlin.com/js7/joc/resources/joc/
        - name: js7con
          image: "{{ .Values.imageController.repository }}:{{ .Values.imageController.tag | default .Chart.AppVersion }}"
          ports:
            - name: http
              containerPort: {{ .Values.serviceController.port }}
              protocol: TCP
        - name: js7ag
          image: "{{ .Values.imageAgent.repository }}:{{ .Values.imageAgent.tag | default .Chart.AppVersion }}"
          ports:
            - name: http
              containerPort: {{ .Values.serviceAgent.port }}
              protocol: TCP
          resources:
            {{- toYaml .Values.resources | nindent 12 }}
      {{- with .Values.nodeSelector }}
      nodeSelector:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      {{- with .Values.affinity }}
      affinity:
        {{- toYaml . | nindent 8 }}
      {{- end }}
      {{- with .Values.tolerations }}
      tolerations:
        {{- toYaml . | nindent 8 }}
      {{- end }}

The YAML file describes a single Pod for deployment to Kubernetes which is a group of one or more containers and a ConfigMap. The Pod includes three containers:

  1. The js7joc container runs the joc-2-5-1 image and exposes port 4446. It uses a ConfigMap with the name hibernate-config to specify a volume mounted to the /var/sos-berlin.com/js7/joc/resources/joc directory.
  2. The js7con container runs the controller-2-5-1 image and exposes port 4444.
  3. The js7agent container runs the agent-2-5-1 image and exposes port 4445.

The following implications apply:

  • Each container runs a different image from the sosberlin/js7 repository and is assigned a unique port.

  • For the js7joc container the volumeMounts element specifies the hibernate-config ConfigMap which is mounted to the /var/sos-berlin.com/js7/joc/resources/joc directory.

Values for Kubernetes JS7 deployment file: js7-service.yaml

Example for values.yaml
replicaCount: 1
image:
  repository: sosberlin/js7
  pullPolicy: IfNotPresent
  tag: "joc-2-5-1"
imageController:
  repository: sosberlin/js7
  pullPolicy: IfNotPresent
  tag: "controller-2-5-1"
imageAgent:
  repository: sosberlin/js7
  pullPolicy: IfNotPresent
  tag: "agent-2-5-1"
imagePullSecrets: []
nameOverride: ""
fullnameOverride: ""
serviceAccount:
  create: true
  annotations: {}
  name: ""
podAnnotations: {}
podSecurityContext: {}
securityContext: {}
service:
  type: ClusterIP
  port: 4446
serviceController:
  type: ClusterIP
  port: 4444
serviceAgent:
  type: ClusterIP
  port: 4445
ingress:
  enabled: false
  className: ""
  annotations: {}
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: ImplementationSpecific
  tls: []
resources: {}
autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 100
  targetCPUUtilizationPercentage: 80
nodeSelector: {}
tolerations: []
affinity: {}

Step-by-Step Instructions

To operate JOC Cockpit in a Kubernetes Cluster with the helm chart users adjust the values.yaml file that specifies the container images and port forwarded.

  1. Download the archive file: buildachart_js7_working.zip. Open a console window from the directory where you downloaded the .zip archive and extract the archive.


  2. Execute the below command to deploy working charts using the helm install command. We can do a dry-run of a helm install and enable debug to inspect the generated definitions. The service.internalPort value is used here to ensure that the Service and Deployment objects work together correctly.

    helm install buildachart_js7_working --dry-run --debug ./buildachart_js7_working --set service.internalPort=4446



  3. Run the below command to run the pods on the internal port.

    helm install js7 ./buildachart_js7_working --set service.type=NodePort

Further Resources