Skip to main content

Website | Hoe rancher te gebruiken - Howto use rancher

Click here for the English version

In deze handleiding worden meerdere manieren aangegeven hoe u een applicatie in een container kunt deployen op een Rancher kubernetes cluster. Daarnaast wordt uitgelegd hoe u de logs kunt uitlezen van een applicatie en hoe u een applicatie container kan herstarten.

Deployen via Rancher door middel van YAML:

Door de opzet op te zetten in YAML heeft u meer vrijheid om onderdelen beter te kunnen instellen. Dit geeft u meer controle over de configuratie. Het onderstaande stappenplan zorgt ervoor dat de container beschikbaar wordt.

Maak een bestand aan voor de deployment. Hieronder vind u een voorbeeld deployment YAML. Pas de onderdelen aan wat tussen de <> staat. Upload de deployment YAML naar het cluster toe in de juiste namespace. Moet de container communiceren met een andere container dan moet u de voorbeelden poorten openen, Environment variabelen en Voorbeeld Service YAML volgen. Moet de container ook via een url beschikbaar worden, volg dat ook Voorbeeld Ingress YAML er nog bij.

  1. U krijgt via een reactie op het aanvraag formulier te horen welke url u moet gebruiken en welk cluster en namespace voor u is aangemaakt.
  2. Login op https://prod.k8s.rug.nl de Rancher UI.
  3. Selecteer het cluster waarin u wilt deployen.
  4. Upload de deployment YAML bij Workloads -> Deployments -> Create. Zou u geen invoerblok zien, klik dan onderaan op de knop Edit as YAML. Plak het bestand en druk op Create.
  5. Zou u een Service YAML gedefinieerd hebben, Voer dan dezelfde stap uit als bij stap 5 maar dan bij Service Discovery -> Services -> Create -> Cluster IP. Zou u geen invoerblok zien, klik dan onderaan op de knop Edit as YAML en vervang hetgene met de aangepaste Voorbeeld Service YAML.
  6. Zou u een Ingress YAML gedefinieerd hebben, Voer dan dezelfde stap uit als bij stap 5 maar dan bij Service Discovery -> Ingresses -> Create. Zou u geen invoerblok zien, klik dan onderaan op de knop Edit as YAML en vervang hetgene met de aangepaste Voorbeeld Ingress YAML.
  7. Controleer of alles werkt.

Voorbeeld deployment YAML

Een deployment YAML wordt gebruikt om de container en componenten te definieren. Hieronder is een voorbeeld gegeven met uitleg:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: <app-naam>                                  <-- naam van de applicatie of website
  name: <naam-deployment>                            <-- naam van de deployment
  namespace: <naam-namespace>                        <-- naam van de namespace
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: <app-naam>                                <-- naam van de applicatie of website
  strategy:
    rollingUpdate:
      maxSurge: 0
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: <app-naam>                              <-- naam van de applicatie of website
      namespace: <naam-namespace>
    spec:
      containers:
      - image: <adres-container>:latest              <-- adres van container()
        imagePullPolicy: Always
        env: {}
        name: <naam-container>                       <-- naam container
        ports: {}
        resources: {}
        securityContext:
          allowPrivilegeEscalation: false
          privileged: false
          procMount: Default
          readOnlyRootFilesystem: false
          runAsNonRoot: false
        stdin: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        tty: true
      dnsPolicy: ClusterFirst
      hostAliases:
      - hostnames:
        - mysql01.service.rug.nl
        ip: 192.168.65.3
      imagePullSecrets:
      - name: <naam-pull-secret>                     <-- naam van de registry pull secret
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30

Uitleg

Environment variabelen

Om environment variabelen toe te voegen moet het volgende aan de bovenstaande deployment YAML bestand aangepast worden. Dit werkt op naam waarde basis. Er kunnen een of meerdere naam waarde paren gedefinieerd worden.

        env:
          - name: IETS
            value: "hallo wereld"
Poorten openen

Om poorten te openen moet er het volgende worden toegevoegd in de bovenstaande deployment YAML. Dit werkt op naam waarde basis. Er kunnen een of meerdere naam waarde paren gedefinieerd worden.

        ports:
        - containerPort: <poort-nummer>
          name: <poort-naam>
          protocol: TCP

Voorbeeld Service YAML

apiVersion: v1
kind: Service
metadata:
  name: <naam-service>                               <-- naam van de service
  namespace: <naam-namespace>                        <-- naam van de namespace
spec:
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - name: <poort-naam>                               <-- naam van de poort gedefinieerd in de deployment YAML
    port: <poort-nummer>                             <-- inkomende poort nummer gedefinieerd in de deployment YAML
    protocol: TCP
    targetPort: <poort-nummer>                       <-- poort nummer naar deployment toe
  selector:
    app: <app-naam>                                  <-- naam van de applicatie of website
  sessionAffinity: None
  type: ClusterIP

Voorbeeld Ingress YAML

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: <naam-ingress>                                <-- naam van de ingress
  namespace: <naam-namespace>                         <-- naam van de namespace
spec:
  ingressClassName: nginx
  rules:
  - host: <adres-website>                             <-- url website
    http:
      paths:
      - backend:
          service:
            name: <naam-service>                      <-- naam van de service gedefinieerd in de Service YAML
            port:
              number: <inkomende-poort>               <-- inkomende poort nummer gedefinieerd in de Service YAML
        pathType: ImplementationSpecific
  tls:
  - hosts:
    - <adres-website>                                 <-- url website

Deployen via Helm Charts:

Helm is een package manager voor Kubernetes. Het stelt u in staat om complexe applicaties te definiëren, installeren en upgraden met behulp van "charts". Rancher integreert goed met Helm.

  1. Voeg Helm Repositories toe (indien nodig): Als de chart die u wilt gebruiken zich in een externe repository bevindt, moet u deze eerst toevoegen aan Rancher. Ga naar het cluster, selecteer "Apps & Marketplace" en vervolgens "Repositories". Klik op "Create" om een nieuwe repository toe te voegen. Hier kunt u de repositories verversen om de nieuwste charts binnen te halen.
  2. Lanceer een Chart:
  3. Selecteer "Apps & Marketplace".
  4. Zoek de chart die u wilt deployen (uit de catalogus of een toegevoegde repository).
  5. Klik op de chart en vervolgens op "Install".
  6. Configureer de chart parameters via het formulier of door de YAML-waarden te bewerken.
  7. Selecteer de target namespace.
  8. Klik op "Install".

Log uitlezen van een container

Voor het uitlezen van een log moet het volgende gebeuren:

  1. Open een webbrowser
  2. Login op rancher
  3. Ga naar het gewenste cluster
  4. Ga naar Workloads -> Pods
  5. Zoek de juiste pod op en druk op de drie verticale puntjes aan de rechterkant
  6. In het verschenen menu, klik op View Logs

Herstarten container

Om een container te kunnen herstarten, moet het volgende uitgevoerd worden:

  1. Open een webbrowser
  2. Login op rancher
  3. Ga naar het gewenste cluster
  4. Ga naar Workloads -> Deployments
  5. Zoek de juiste pod op en druk op de drie verticale puntjes aan de rechterkant
  6. In het verschenen menu, klik op Redeploy

This guide outlines multiple methods for deploying an application in a container on a Rancher Kubernetes cluster. Additionally, it explains how to read application logs and restart an application container.

Deploying via Rancher using YAML

By setting up the configuration in YAML, you have more freedom to fine-tune components. This gives you greater control over the setup. The step-by-step plan below will make the container available.

Create a file for the deployment. Below you will find an example deployment YAML. Adjust the parts enclosed within <>. Upload the deployment YAML to the cluster in the correct namespace. If the container needs to communicate with another container, you should follow the examples for opening ports, environment variables and the Service YAML example. If the container also needs to be accessible via a URL, then also include the Ingress YAML example.

Deployment Steps

  1. You will receive the URL to use and the cluster and namespace created for you via a response to the application form.
  2. Log in to the Rancher UI at https://prod.k8s.rug.nl.
  3. Select the cluster where you want to deploy.
  4. Upload the deployment YAML under Workloads -> Deployments -> Create. If you don't see an input block, click the Edit as YAML button at the bottom. Paste the file and click Create.
  5. If you have defined a Service YAML, perform the same step as in step 4, but under Service Discovery -> Services -> Create -> Cluster IP. If you don't see an input block, click the Edit as YAML button at the bottom and replace the content with your customized Service YAML example.
  6. If you have defined an Ingress YAML, perform the same step as in step 4, but under Service Discovery -> Ingresses -> Create. If you don't see an input block, click the Edit as YAML button at the bottom and replace the content with your customized Ingress YAML example.
  7. Verify that everything is working.

Deployment YAML example

A deployment YAML is used to define the container. An example with explanations is provided below:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: <app-name>                                   <-- name of the application or website
  name: <deployment-name>                             <-- name of the deployment
  namespace: <namespace-name>                         <-- name of the namespace
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: <app-name>                                 <-- name of the application or website
  strategy:
    rollingUpdate:
      maxSurge: 0
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: <app-name>                               <-- name of the application or website
      namespace: <namespace-name>
    spec:
      containers:
      - image: <container-address>:latest             <-- address of the container
        imagePullPolicy: Always
        env: {}
        name: <container-name>                        <-- container name
        ports: {}
        resources: {}
        securityContext:
          allowPrivilegeEscalation: false
          privileged: false
          procMount: Default
          readOnlyRootFilesystem: false
          runAsNonRoot: false
        stdin: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        tty: true
      dnsPolicy: ClusterFirst
      hostAliases:
      - hostnames:
        - mysql01.service.rug.nl
        ip: 192.168.65.3
      imagePullSecrets:
      - name: <pull-secret-name>                      <-- name of the registry pull secret
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30

Explanation

Environment Variables

To add environment variables, the following section needs to be adjusted in the deployment YAML file mentioned above. This works on a name-value pair basis. One or more name-value pairs can be defined.

        env:
          - name: SOMETHING
            value: "hello world"
Opening Ports

To open ports, the following needs to be added to the deployment YAML file above. This also works on a name-value pair basis. One or more name-value pairs can be defined.

        ports:
        - containerPort: <port-number>
          name: <port-name>
          protocol: TCP

Service YAML example

apiVersion: v1
kind: Service
metadata:
  name: <service-name>                                <-- name of the service
  namespace: <namespace-name>                         <-- name of the namespace
spec:
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - name: <port-name>                                 <-- name of the port defined in the deployment YAML
    port: <port-number>                               <-- incoming port number defined in the deployment YAML
    protocol: TCP
    targetPort: <port-number>                         <-- port number for the deployment
  selector:
    app: <app-name>                                   <-- name of the application or website
  sessionAffinity: None
  type: ClusterIP

Ingress YAML example

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: <ingress-name>                                <-- name of the ingress
  namespace: <namespace-name>                         <-- name of the namespace
spec:
  ingressClassName: nginx
  rules:
  - host: <website-address>                           <-- website URL
    http:
      paths:
      - backend:
          service:
            name: <service-name>                      <-- name of the service defined in the Service YAML
            port:
              number: <incoming-port>                 <-- incoming port number defined in the Service YAML
        pathType: ImplementationSpecific
  tls:
  - hosts:
    - <website-address>                               <-- website URL

Deploying using Helm charts

Helm is a package manager for Kubernetes. It allows you to define, install, and upgrade complex applications using "charts." Rancher integrates well with Helm.

  1. Add Helm Repositories (if needed): If the chart you want to use is in an external repository, you'll need to add it to Rancher first. Go to your cluster, select Apps & Marketplace, then Repositories. Click Create to add a new repository. Here, you can also refresh the repositories to pull in the latest charts.
  2. Launch a Chart:
  3. Select Apps & Marketplace.
  4. Find the chart you want to deploy (from the catalog or an added repository).
  5. Click on the chart, then click Install.
  6. Configure the chart parameters via the form or by editing the YAML values.
  7. Select the target namespace.
  8. Click Install.

Reading logs of a container

To view logs, follow these steps:

  1. Open a web browser.
  2. Log in to Rancher.
  3. Navigate to the desired cluster.
  4. Go to Workloads -> Pods.
  5. Locate the correct pod and click on the three vertical dots on the right side.
  6. In the menu that appears, click on View Logs.

Restart container

To restart a container, you'll need to perform the following steps:

  1. Open a web browser.
  2. Log in to Rancher.
  3. Navigate to the desired cluster.
  4. Go to Workloads -> Deployments.
  5. Locate the correct pod and click on the three vertical dots on the right side.
  6. In the menu that appears, click on Redeploy.
Back to top