Questo contenuto non è disponibile nella lingua selezionata.

Chapter 2. Deploying an application workshop

2.1. Workshop overview
Copia collegamento

2.1.1. Introduction
Copia collegamento

After successfully provisioning your cluster, follow this workshop to deploy an application on it to understand the concepts of deploying and operating container-based applications.

Workshop objectives

Deploy a Node.js-based application by using Source-to-Image (S2I) and Kubernetes deployment objects
Set up a continuous delivery (CD) pipeline to automatically push source code changes
Experience self-healing applications
Explore configuration management through ConfigMaps, secrets, and environment variables
Use persistent storage to share data across pod restarts
Explore networking in Kubernetes and applications
Familiarize yourself with ROSA and Kubernetes functionality
Automatically scale pods based on loads from the Horizontal Pod Autoscaler (HPA)

Prerequisites

A provisioned ROSA cluster
The OpenShift command-line interface (CLI)
A GitHub account

2.1.2. About the OSToy application
Copia collegamento

OSToy is a Node.js application that deploys to a ROSA cluster to help explore the functionality of Kubernetes.

This application has a user interface where you can:

Write messages to the log (stdout / stderr)
Intentionally crash the application to view self-healing
Toggle a liveness probe and monitor OpenShift behavior
Read ConfigMaps, secrets, and environment variables
Read and write files when connected to shared storage
Check network connectivity, intra-cluster DNS, and intra-communication with the included microservice
Increase the load to view automatic scaling of the pods by using the HPA

2.1.2.1. OSToy application diagram
Copia collegamento

2.1.2.2. Understanding the OSToy UI
Copia collegamento

Pod name
Home: Application home page
Persistent Storage: Writes data to the persistent volume bound to the application
Config Maps: Shows ConfigMaps available to the application and the key:value pairs
Secrets: Shows secrets available to the application and the key:value pairs
ENV Variables: Shows environment variables available to the application
Networking: Networking tools
Pod Auto Scaling: Increase the load of the pods and test the Horizontal Pod Autoscaler (HPA)
ACK S3: Integrate with AWS S3 to read and write objects to a bucket
About: Application information

2.1.2.3. Lab resources
Copia collegamento

OSToy application source code
OSToy front-end container image
OSToy microservice container image

Deployment definition YAML files:

ostoy-frontend-deployment.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ostoy-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ostoy-frontend
  labels:
    app: ostoy
spec:
  selector:
    matchLabels:
      app: ostoy-frontend
  strategy:
    type: Recreate
  replicas: 1
  template:
    metadata:
      labels:
        app: ostoy-frontend
    spec:
      # Uncomment to use with ACK portion of the workshop
      # If you chose a different service account name please replace it.
      # serviceAccount: ostoy-sa
      containers:
      - name: ostoy-frontend
        securityContext:
          allowPrivilegeEscalation: false
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
          capabilities:
            drop:
            - ALL
        image: quay.io/ostoylab/ostoy-frontend:1.6.0
        imagePullPolicy: IfNotPresent
        ports:
        - name: ostoy-port
          containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "200m"
        volumeMounts:
        - name: configvol
          mountPath: /var/config
        - name: secretvol
          mountPath: /var/secret
        - name: datavol
          mountPath: /var/demo_files
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
        env:
        - name: ENV_TOY_SECRET
          valueFrom:
            secretKeyRef:
              name: ostoy-secret-env
              key: ENV_TOY_SECRET
        - name: MICROSERVICE_NAME
          value: OSTOY_MICROSERVICE_SVC
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
      volumes:
        - name: configvol
          configMap:
            name: ostoy-configmap-files
        - name: secretvol
          secret:
            defaultMode: 420
            secretName: ostoy-secret
        - name: datavol
          persistentVolumeClaim:
            claimName: ostoy-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: ostoy-frontend-svc
  labels:
    app: ostoy-frontend
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: ostoy-port
      protocol: TCP
      name: ostoy
  selector:
    app: ostoy-frontend
---
apiVersion: route.openshift.io/v1
kind: Route
metadata:
  name: ostoy-route
spec:
  to:
    kind: Service
    name: ostoy-frontend-svc
---
apiVersion: v1
kind: Secret
metadata:
  name: ostoy-secret-env
type: Opaque
data:
  ENV_TOY_SECRET: VGhpcyBpcyBhIHRlc3Q=
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: ostoy-configmap-files
data:
  config.json:  '{ "default": "123" }'
---
apiVersion: v1
kind: Secret
metadata:
  name: ostoy-secret
data:
  secret.txt: VVNFUk5BTUU9bXlfdXNlcgpQQVNTV09SRD1AT3RCbCVYQXAhIzYzMlk1RndDQE1UUWsKU01UUD1sb2NhbGhvc3QKU01UUF9QT1JUPTI1
type: Opaque

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ostoy-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ostoy-frontend
  labels:
    app: ostoy
spec:
  selector:
    matchLabels:
      app: ostoy-frontend
  strategy:
    type: Recreate
  replicas: 1
  template:
    metadata:
      labels:
        app: ostoy-frontend
    spec:
      # Uncomment to use with ACK portion of the workshop
      # If you chose a different service account name please replace it.
      # serviceAccount: ostoy-sa
      containers:
      - name: ostoy-frontend
        securityContext:
          allowPrivilegeEscalation: false
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
          capabilities:
            drop:
            - ALL
        image: quay.io/ostoylab/ostoy-frontend:1.6.0
        imagePullPolicy: IfNotPresent
        ports:
        - name: ostoy-port
          containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "200m"
        volumeMounts:
        - name: configvol
          mountPath: /var/config
        - name: secretvol
          mountPath: /var/secret
        - name: datavol
          mountPath: /var/demo_files
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
        env:
        - name: ENV_TOY_SECRET
          valueFrom:
            secretKeyRef:
              name: ostoy-secret-env
              key: ENV_TOY_SECRET
        - name: MICROSERVICE_NAME
          value: OSTOY_MICROSERVICE_SVC
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
      volumes:
        - name: configvol
          configMap:
            name: ostoy-configmap-files
        - name: secretvol
          secret:
            defaultMode: 420
            secretName: ostoy-secret
        - name: datavol
          persistentVolumeClaim:
            claimName: ostoy-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: ostoy-frontend-svc
  labels:
    app: ostoy-frontend
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: ostoy-port
      protocol: TCP
      name: ostoy
  selector:
    app: ostoy-frontend
---
apiVersion: route.openshift.io/v1
kind: Route
metadata:
  name: ostoy-route
spec:
  to:
    kind: Service
    name: ostoy-frontend-svc
---
apiVersion: v1
kind: Secret
metadata:
  name: ostoy-secret-env
type: Opaque
data:
  ENV_TOY_SECRET: VGhpcyBpcyBhIHRlc3Q=
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: ostoy-configmap-files
data:
  config.json:  '{ "default": "123" }'
---
apiVersion: v1
kind: Secret
metadata:
  name: ostoy-secret
data:
  secret.txt: VVNFUk5BTUU9bXlfdXNlcgpQQVNTV09SRD1AT3RCbCVYQXAhIzYzMlk1RndDQE1UUWsKU01UUD1sb2NhbGhvc3QKU01UUF9QT1JUPTI1
type: Opaque

Copy to Clipboard

Toggle word wrap

ostoy-microservice-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ostoy-microservice
  labels:
    app: ostoy
spec:
  selector:
    matchLabels:
      app: ostoy-microservice
  replicas: 1
  template:
    metadata:
      labels:
        app: ostoy-microservice
    spec:
      containers:
      - name: ostoy-microservice
        securityContext:
          allowPrivilegeEscalation: false
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
          capabilities:
            drop:
            - ALL
        image: quay.io/ostoylab/ostoy-microservice:1.5.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          requests:
            memory: "128Mi"
            cpu: "50m"
          limits:
            memory: "256Mi"
            cpu: "100m"
---
apiVersion: v1
kind: Service
metadata:
  name: ostoy-microservice-svc
  labels:
    app: ostoy-microservice
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
  selector:
    app: ostoy-microservice

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ostoy-microservice
  labels:
    app: ostoy
spec:
  selector:
    matchLabels:
      app: ostoy-microservice
  replicas: 1
  template:
    metadata:
      labels:
        app: ostoy-microservice
    spec:
      containers:
      - name: ostoy-microservice
        securityContext:
          allowPrivilegeEscalation: false
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
          capabilities:
            drop:
            - ALL
        image: quay.io/ostoylab/ostoy-microservice:1.5.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          requests:
            memory: "128Mi"
            cpu: "50m"
          limits:
            memory: "256Mi"
            cpu: "100m"
---
apiVersion: v1
kind: Service
metadata:
  name: ostoy-microservice-svc
  labels:
    app: ostoy-microservice
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
  selector:
    app: ostoy-microservice

Copy to Clipboard

Toggle word wrap

S3 bucket manifest for ACK S3

s3-bucket.yaml

apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
  name: ostoy-bucket
  namespace: ostoy
spec:
  name: ostoy-bucket

apiVersion: s3.services.k8s.aws/v1alpha1
kind: Bucket
metadata:
  name: ostoy-bucket
  namespace: ostoy
spec:
  name: ostoy-bucket

Copy to Clipboard

Toggle word wrap

Note

To simplify deployment of the OSToy application, all of the objects required in the above deployment manifests are grouped together. For a typical enterprise deployment, a separate manifest file for each Kubernetes object is recommended.

2.2. Deploying the OSToy application with Kubernetes
Copia collegamento

Deploying an application involves creating a container image, storing it in an image repository, and defining Deployment object that uses that image.

Deploying an application involves the following steps:

Create the images for the front-end and back-end microservice containers
Store the container images in an image repository
Create the Kubernetes Deployment object for the application
Deploy the application

Note

This workshop focuses on application deployment and has users run a remote file which uses an existing image.

2.2.1. Retrieving the login command
Copia collegamento

Procedure

Confirm you are logged in to the command-line interface (CLI) by running the following command:
```
rosa whoami
```
```
rosa whoami
```
Copy to Clipboard Toggle word wrap
If you are logged in to the command-line interface, skip to "Creating a new project". If you are not logged in to the command-line interface, continue this procedure.
Access your cluster with the web console.
Click the dropdown arrow next to your login name in the upper right corner, and select Copy Login Command.

View larger image

A new tab opens.
Select your authentication method.
Click Display Token.
Copy the command under Log in with this token.

From your terminal, paste and run the copied command. If the login is successful, you will see the following confirmation message:

oc login --token=<your_token> --server=https://api.osd4-demo.abc1.p1.openshiftapps.com:6443

$ oc login --token=<your_token> --server=https://api.osd4-demo.abc1.p1.openshiftapps.com:6443
Logged into "https://api.myrosacluster.abcd.p1.openshiftapps.com:6443" as "rosa-user" using the token provided.

You don't have any projects. You can try to create a new project, by running

oc new-project <project name>

Copy to Clipboard

Toggle word wrap

2.2.2. Creating a new project
Copia collegamento

Use your preferred interface to create a new project.

2.2.2.1. Creating a new project using the CLI
Copia collegamento

Procedure

Create a new project named ostoy in your cluster by running following command:

oc new-project ostoy

$ oc new-project ostoy

Copy to Clipboard

Toggle word wrap

Example output

Now using project "ostoy" on server "https://api.myrosacluster.abcd.p1.openshiftapps.com:6443".

Now using project "ostoy" on server "https://api.myrosacluster.abcd.p1.openshiftapps.com:6443".

Copy to Clipboard

Toggle word wrap

Optional: Create a unique project name by running the following command:

oc new-project ostoy-$(uuidgen | cut -d - -f 2 | tr '[:upper:]' '[:lower:]')

$ oc new-project ostoy-$(uuidgen | cut -d - -f 2 | tr '[:upper:]' '[:lower:]')

Copy to Clipboard

Toggle word wrap

2.2.2.2. Creating a new project using the web console
Copia collegamento

Procedure

From the web console, click Home Projects.
On the Projects page, click create Create Project.

View larger image
In the Create Project box, enter a project name in the Name field.
Click Create.

2.2.3. Deploying the back-end microservice
Copia collegamento

The microservice serves internal web requests and returns a JSON object containing the current hostname and a randomly generated color string.

Procedure

Deploy the microservice by running the following command:

oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-microservice-deployment.yaml

$ oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-microservice-deployment.yaml

Copy to Clipboard

Toggle word wrap

Example output

oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-microservice-deployment.yaml

$ oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-microservice-deployment.yaml
deployment.apps/ostoy-microservice created
service/ostoy-microservice-svc created

Copy to Clipboard

Toggle word wrap

2.2.4. Deploying the front-end microservice
Copia collegamento

The front-end deployment uses the Node.js front-end for the application and additional Kubernetes objects.

Front-end deployment defines the following features:

Persistent volume claim
Deployment object
Service
Route
ConfigMaps
Secrets

Procedure

Deploy the application front-end and create the objects by running the following command:

oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-frontend-deployment.yaml

$ oc apply -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/ostoy-frontend-deployment.yaml

Copy to Clipboard

Toggle word wrap

Example output

persistentvolumeclaim/ostoy-pvc created
deployment.apps/ostoy-frontend created
service/ostoy-frontend-svc created
route.route.openshift.io/ostoy-route created
configmap/ostoy-configmap-env created
secret/ostoy-secret-env created
configmap/ostoy-configmap-files created
secret/ostoy-secret created

persistentvolumeclaim/ostoy-pvc created
deployment.apps/ostoy-frontend created
service/ostoy-frontend-svc created
route.route.openshift.io/ostoy-route created
configmap/ostoy-configmap-env created
secret/ostoy-secret-env created
configmap/ostoy-configmap-files created
secret/ostoy-secret created

Copy to Clipboard

Toggle word wrap

All objects should create successfully.

2.2.5. Obtain the route to your application
Copia collegamento

Obtain the route to access the application.

Procedure

Get the route to your application by running the following command:

oc get route

$ oc get route

Copy to Clipboard

Toggle word wrap

Example output

NAME          HOST/PORT                                                 PATH   SERVICES             PORT    TERMINATION   WILDCARD
ostoy-route   ostoy-route-ostoy.apps.<your-rosa-cluster>.abcd.p1.openshiftapps.com          ostoy-frontend-svc   <all>                 None

NAME          HOST/PORT                                                 PATH   SERVICES             PORT    TERMINATION   WILDCARD
ostoy-route   ostoy-route-ostoy.apps.<your-rosa-cluster>.abcd.p1.openshiftapps.com          ostoy-frontend-svc   <all>                 None

Copy to Clipboard

Toggle word wrap

2.2.6. Viewing the application
Copia collegamento

Procedure

Copy the ostoy-route-ostoy.apps.<your-rosa-cluster>.abcd.p1.openshiftapps.com URL output from the previous step.
Paste the copied URL into your web browser and press enter. You should see the homepage of your application. If the page does not load, make sure you used http and not https.

View larger image

2.3. Health check
Copia collegamento

See how Kubernetes responds to pod failure by intentionally crashing your pod and making it unresponsive to the Kubernetes liveness probes.

2.3.1. Preparing your desktop
Copia collegamento

Procedure

From the OpenShift web console, select Workloads > Deployments > ostoy-frontend to view the OSToy deployment.

View larger image

2.3.2. Crashing the pod
Copia collegamento

Procedure

From the OSToy application web console, click Home in the left menu, and enter a message in the Crash Pod box, for example, This is goodbye!.
Click Crash Pod.

View larger image

The pod crashes and Kubernetes restarts the pod.

View larger image

2.3.3. Viewing the revived pod
Copia collegamento

Procedure

From the OpenShift web console, quickly switch to the Deployments screen. You will see that the pod turns yellow, which means it is down. It should quickly revive and turn blue. The revival process happens quickly.

View larger image

Verification

From the web console, click Pods > ostoy-frontend-xxxxxxx-xxxx to change to the pods screen.

View larger image
Click the Events subtab, and verify that the container crashed and restarted.

View larger image

2.3.4. Making the application malfunction
Copia collegamento

Procedure

~~. Keep the pod events page open.~~

From the OSToy application, click Toggle Health in the Toggle Health Status tile. Watch Current Health switch to I’m not feeling all that well.

View larger image

Verification

After you make the application malfunction, the application stops responding with a 200 HTTP code. After 3 consecutive failures, Kubernetes stops the pod and restarts it.

From the web console, switch back to the pod events page to see that the liveness probe failed and the pod restarted.

The following image shows an example of what you will see on your pod events page.

A. The pod has three consecutive failures.

B. Kubernetes stops the pod.

C. Kubernetes restarts the pod.

2.4. Persistent volumes for cluster storage
Copia collegamento

{rosa-classic-first} and Red Hat OpenShift Service on AWS (ROSA) support storing persistent volumes with either Amazon Web Services (AWS) Elastic Block Store (EBS) or AWS Elastic File System (EFS).

2.4.1. Using persistent volumes
Copia collegamento

Use the following procedures to create a file, store it on a persistent volume in your cluster, and confirm that it still exists after pod failure and re-creation.

2.4.1.1. Viewing a persistent volume claim
Copia collegamento

Procedure

Navigate to the cluster’s OpenShift web console.
Click Storage in the left menu, then click PersistentVolumeClaims to see a list of all the persistent volume claims.
Click a persistence volume claim to see the size, access mode, storage class, and other additional claim details.
Note
The access mode is ReadWriteOnce (RWO). This means that the volume can only be mounted to one node and the pod or pods can read and write to the volume.

2.4.1.2. Storing your file
Copia collegamento

Procedure

In the OSToy app console, click Persistent Storage in the left menu.
In the Filename box, enter a file name with a .txt extension, for example test-pv.txt.
In the File contents box, enter a sentence of text, for example OpenShift is the greatest thing since sliced bread!.
Click Create file.

View larger image
Scroll to Existing files on the OSToy app console.
Click the file you created to see the file name and contents.

View larger image

2.4.1.3. Crashing the pod
Copia collegamento

Procedure

On the OSToy app console, click Home in the left menu.
Click Crash pod.

2.4.1.4. Confirming persistent storage
Copia collegamento

Procedure

Wait for the pod to re-create.
On the OSToy app console, click Persistent Storage in the left menu.
Find the file you created, and open it to view and confirm the contents.

View larger image

Verification

The deployment YAML file shows that we mounted the directory /var/demo_files to our persistent volume claim.

Retrieve the name of your front-end pod by running the following command:
```
oc get pods
```
```
$ oc get pods
```
Copy to Clipboard Toggle word wrap
Start a secure shell (SSH) session in your container by running the following command:
```
oc rsh <pod_name>
```
```
$ oc rsh <pod_name>
```
Copy to Clipboard Toggle word wrap
Go to the directory by running the following command:
```
cd /var/demo_files
```
```
$ cd /var/demo_files
```
Copy to Clipboard Toggle word wrap
Optional: See all the files you created by running the following command:
```
ls
```
```
$ ls
```
Copy to Clipboard Toggle word wrap
Open the file to view the contents by running the following command:
```
cat test-pv.txt
```
```
$ cat test-pv.txt
```
Copy to Clipboard Toggle word wrap

Verify that the output is the text you entered in the OSToy app console.

Example terminal

oc get pods
oc rsh ostoy-frontend-5fc8d486dc-wsw24
cd /var/demo_files/
ls
cat test-pv.txt

$ oc get pods
NAME                                  READY     STATUS    RESTARTS   AGE
ostoy-frontend-5fc8d486dc-wsw24       1/1       Running   0          18m
ostoy-microservice-6cf764974f-hx4qm   1/1       Running   0          18m

$ oc rsh ostoy-frontend-5fc8d486dc-wsw24

$ cd /var/demo_files/

$ ls
lost+found   test-pv.txt

$ cat test-pv.txt
OpenShift is the greatest thing since sliced bread!

Copy to Clipboard

Toggle word wrap

2.4.1.5. Ending the session
Copia collegamento

Procedure

Type exit in your terminal to quit the session and return to the CLI.

2.5. ConfigMaps, secrets, and environment variables
Copia collegamento

This tutorial shows how to configure the OSToy application by using config maps, secrets, and environment variables.

2.5.1. Configuration using ConfigMaps
Copia collegamento

Config maps allow you to decouple configuration artifacts from container image content to keep containerized applications portable.

Procedure

In the OSToy app, in the left menu, click Config Maps, displaying the contents of the config map available to the OSToy application. The code snippet shows an example of a config map configuration:
Example output
```
kind: ConfigMap
apiVersion: v1
metadata:
  name: ostoy-configmap-files
data:
  config.json:  '{ "default": "123" }'
```
```
kind: ConfigMap
apiVersion: v1
metadata:
  name: ostoy-configmap-files
data:
  config.json:  '{ "default": "123" }'
```
Copy to Clipboard Toggle word wrap

2.5.2. Configuration using secrets
Copia collegamento

Kubernetes Secret objects allow you to store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. Putting this information in a secret is safer and more flexible than putting it in plain text into a pod definition or a container image.

Procedure

In the OSToy app, in the left menu, click Secrets, displaying the contents of the secrets available to the OSToy application. The code snippet shows an example of a secret configuration:

Example output

USERNAME=my_user
PASSWORD=VVNFUk5BTUU9bXlfdXNlcgpQQVNTV09SRD1AT3RCbCVYQXAhIzYzMlk1RndDQE1UUWsKU01UUD1sb2NhbGhvc3QKU01UUF9QT1JUPTI1
SMTP=localhost
SMTP_PORT=25

USERNAME=my_user
PASSWORD=VVNFUk5BTUU9bXlfdXNlcgpQQVNTV09SRD1AT3RCbCVYQXAhIzYzMlk1RndDQE1UUWsKU01UUD1sb2NhbGhvc3QKU01UUF9QT1JUPTI1
SMTP=localhost
SMTP_PORT=25

Copy to Clipboard

Toggle word wrap

2.5.3. Configuration using environment variables
Copia collegamento

Using environment variables is an easy way to change application behavior without requiring code changes. It allows different deployments of the same application to potentially behave differently based on the environment variables. Red Hat OpenShift Service on AWS makes it simple to set, view, and update environment variables for pods or deployments.

Procedure

In the OSToy app, in the left menu, click ENV Variables, displaying the environment variables available to the OSToy application. The code snippet shows an example of an environmental variable configuration:

Example output

{
  "npm_config_local_prefix": "/opt/app-root/src",
  "STI_SCRIPTS_PATH": "/usr/libexec/s2i",
  "npm_package_version": "1.7.0",
  "APP_ROOT": "/opt/app-root",
  "NPM_CONFIG_PREFIX": "/opt/app-root/src/.npm-global",
  "OSTOY_MICROSERVICE_PORT_8080_TCP_PORT": "8080",
  "NODE": "/usr/bin/node",
  "LD_PRELOAD": "libnss_wrapper.so",
  "KUBERNETES_SERVICE_HOST": "172.30.0.1",
  "OSTOY_MICROSERVICE_PORT": "tcp://172.30.60.255:8080",
  "OSTOY_PORT": "tcp://172.30.152.25:8080",
  "npm_package_name": "ostoy",
  "OSTOY_SERVICE_PORT_8080_TCP": "8080",
  "_": "/usr/bin/node"
  "ENV_TOY_CONFIGMAP": "ostoy-configmap -env"
}

{
  "npm_config_local_prefix": "/opt/app-root/src",
  "STI_SCRIPTS_PATH": "/usr/libexec/s2i",
  "npm_package_version": "1.7.0",
  "APP_ROOT": "/opt/app-root",
  "NPM_CONFIG_PREFIX": "/opt/app-root/src/.npm-global",
  "OSTOY_MICROSERVICE_PORT_8080_TCP_PORT": "8080",
  "NODE": "/usr/bin/node",
  "LD_PRELOAD": "libnss_wrapper.so",
  "KUBERNETES_SERVICE_HOST": "172.30.0.1",
  "OSTOY_MICROSERVICE_PORT": "tcp://172.30.60.255:8080",
  "OSTOY_PORT": "tcp://172.30.152.25:8080",
  "npm_package_name": "ostoy",
  "OSTOY_SERVICE_PORT_8080_TCP": "8080",
  "_": "/usr/bin/node"
  "ENV_TOY_CONFIGMAP": "ostoy-configmap -env"
}

Copy to Clipboard

Toggle word wrap

2.6. Networking
Copia collegamento

The OSToy application uses intra-cluster networking to separate functions by using microservices.

In this workshop, there are at least two separate pods, each with its own service. One pod functions as the front end web application with a service and a publicly accessible route. The other pod functions as the backend microservice with a service object so that the front end pod can communicate with the microservice.

Communication occurs across the pods if there is more than one pod. The microservice is not accessible from outside the cluster and other namespaces or projects. The purpose of the microservice is to serve internal web requests and return a JSON object containing the current hostname (the pod’s name) and a randomly generated color string. This color string displays a box with that color on the OSToy application web console.

For more information about the networking limitations, see About network policy.

2.6.1. Intra-cluster networking
Copia collegamento

You can view your networking configurations in your OSToy application.

Procedure

In the OSToy application web console, click Networking in the left menu.
Review the networking configuration. The tile "Hostname Lookup" illustrates how the service name created for a pod translates into an internal ClusterIP address.

View larger image

Enter the name of the microservice created in the "Hostname Lookup" tile following the format: <service_name>.<namespace>.svc.cluster.local. You can find the microservice name in the service definition of ostoy-microservice.yaml by running the following command:

oc get service <name_of_service> -o yaml

$ oc get service <name_of_service> -o yaml

Copy to Clipboard

Toggle word wrap

Example output

apiVersion: v1
kind: Service
metadata:
  name: ostoy-microservice-svc
  labels:
    app: ostoy-microservice
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
  selector:
    app: ostoy-microservice

apiVersion: v1
kind: Service
metadata:
  name: ostoy-microservice-svc
  labels:
    app: ostoy-microservice
spec:
  type: ClusterIP
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
  selector:
    app: ostoy-microservice

Copy to Clipboard

Toggle word wrap

In this example, the full hostname is ostoy-microservice-svc.ostoy.svc.cluster.local.

An IP address is returned. In this example it is 172.30.165.246. This is the intra-cluster IP address, which is only accessible from within the cluster.

View larger image

2.7. Scaling an application
Copia collegamento

Manually or automatically scale your pods by using the Horizontal Pod Autoscaler (HPA). You can also scale your cluster nodes.

Prerequisites

An active ROSA cluster
A deployed OSToy application

2.7.1. Manual pod scaling
Copia collegamento

You can manually scale your application’s pods by using one of the following methods:

Changing your ReplicaSet or deployment definition
Using the command line
Using the web console

This workshop starts by using only one pod for the microservice. By defining a replica of 1 in your deployment definition, the Kubernetes Replication Controller strives to keep one pod alive. You then learn how to define pod autoscaling by using the Horizontal Pod Autoscaler(HPA) which is based on the load and will scale out more pods when necessary.

Procedure

In the OSToy app, click the Networking tab in the navigational menu.
In the "Intra-cluster Communication" section, locate the box that randomly changes colors. Inside the box, you see the microservice’s pod name. There is only one box in this example because there is only one microservice pod.

View larger image

Confirm that there is only one pod running for the microservice by running the following command:

oc get pods

$ oc get pods

Copy to Clipboard

Toggle word wrap

Example output

NAME                                  READY     STATUS    RESTARTS   AGE
ostoy-frontend-679cb85695-5cn7x       1/1       Running   0          1h
ostoy-microservice-86b4c6f559-p594d   1/1       Running   0          1h

NAME                                  READY     STATUS    RESTARTS   AGE
ostoy-frontend-679cb85695-5cn7x       1/1       Running   0          1h
ostoy-microservice-86b4c6f559-p594d   1/1       Running   0          1h

Copy to Clipboard

Toggle word wrap

Download the ostoy-microservice-deployment.yaml and save it to your local machine.

Change the deployment definition to three pods instead of one by using the following example:

spec:
    selector:
      matchLabels:
        app: ostoy-microservice
    replicas: 3

spec:
    selector:
      matchLabels:
        app: ostoy-microservice
    replicas: 3

Copy to Clipboard

Toggle word wrap

Apply the replica changes by running the following command:
```
oc apply -f ostoy-microservice-deployment.yaml
```
```
$ oc apply -f ostoy-microservice-deployment.yaml
```
Copy to Clipboard Toggle word wrap
Note
You can also edit the ostoy-microservice-deployment.yaml file in the OpenShift Web Console by going to the Workloads > Deployments > ostoy-microservice > YAML tab.

Confirm that there are now 3 pods by running the following command:

oc get pods

$ oc get pods

Copy to Clipboard

Toggle word wrap

The output shows that there are now 3 pods for the microservice instead of only one.

Example output

NAME                                  READY   STATUS    RESTARTS   AGE
ostoy-frontend-5fbcc7d9-rzlgz         1/1     Running   0          26m
ostoy-microservice-6666dcf455-2lcv4   1/1     Running   0          81s
ostoy-microservice-6666dcf455-5z56w   1/1     Running   0          81s
ostoy-microservice-6666dcf455-tqzmn   1/1     Running   0          26m

NAME                                  READY   STATUS    RESTARTS   AGE
ostoy-frontend-5fbcc7d9-rzlgz         1/1     Running   0          26m
ostoy-microservice-6666dcf455-2lcv4   1/1     Running   0          81s
ostoy-microservice-6666dcf455-5z56w   1/1     Running   0          81s
ostoy-microservice-6666dcf455-tqzmn   1/1     Running   0          26m

Copy to Clipboard

Toggle word wrap

Scale the application by using the command-line interface (CLI) or by using the web user interface (UI):
- In the CLI, decrease the number of pods from 3 to 2 by running the following command:
  $ oc scale deployment ostoy-microservice --replicas=2
  Copy to Clipboard Toggle word wrap
- From the navigational menu of the OpenShift web console UI, click Workloads > Deployments > ostoy-microservice.
- Locate the blue circle with a "3 Pod" label in the middle.
- Selecting the arrows next to the circle scales the number of pods. Select the down arrow to 2.
  
  View larger image

Verification

Check your pod counts by using the CLI, the web UI, or the OSToy application:

From the CLI, confirm that you are using two pods for the microservice by running the following command:

oc get pods

$ oc get pods

Copy to Clipboard

Toggle word wrap

Example output

NAME                                  READY   STATUS    RESTARTS   AGE
ostoy-frontend-5fbcc7d9-rzlgz         1/1     Running   0          75m
ostoy-microservice-6666dcf455-2lcv4   1/1     Running   0          50m
ostoy-microservice-6666dcf455-tqzmn   1/1     Running   0          75m

NAME                                  READY   STATUS    RESTARTS   AGE
ostoy-frontend-5fbcc7d9-rzlgz         1/1     Running   0          75m
ostoy-microservice-6666dcf455-2lcv4   1/1     Running   0          50m
ostoy-microservice-6666dcf455-tqzmn   1/1     Running   0          75m

Copy to Clipboard

Toggle word wrap

In the web UI, select Workloads > Deployments > ostoy-microservice.

View larger image
You can also confirm that there are two pods by selecting Networking in the navigation menu of the OSToy application. There should be two colored boxes for the two pods.

View larger image

2.7.2. Pod autoscaling
Copia collegamento

Red Hat OpenShift Service on AWS offers a Horizontal Pod Autoscaler (HPA). The HPA uses metrics to increase or decrease the number of pods when necessary.

Procedure

From the navigational menu of the web UI, select Pod Auto Scaling.

View larger image
Create the HPA by running the following command:
```
oc autoscale deployment/ostoy-microservice --cpu-percent=80 --min=1 --max=10
```
```
$ oc autoscale deployment/ostoy-microservice --cpu-percent=80 --min=1 --max=10
```
Copy to Clipboard Toggle word wrap
This command creates an HPA that maintains between 1 and 10 replicas of the pods controlled by the ostoy-microservice deployment. During deployment, HPA increases and decreases the number of replicas to keep the average CPU use across all pods at 80% and 40 millicores.
On the Pod Auto Scaling > Horizontal Pod Autoscaling page, select Increase the load.
Important
Because increasing the load generates CPU intensive calculations, the page can become unresponsive. This is an expected response. Only click Increase the Load once. For more information about the process, see the microservice’s GitHub repository.
After a few minutes, the new pods display on the page represented by colored boxes.
Note
The page can experience lag.

Verification

Check your pod counts with one of the following methods:

In the OSToy application’s web UI, see the remote pods box:

View larger image

Because there is only one pod, increasing the workload should trigger an increase of pods.

In the CLI, run the following command:

oc get pods --field-selector=status.phase=Running | grep microservice

oc get pods --field-selector=status.phase=Running | grep microservice

Copy to Clipboard

Toggle word wrap

Example output

ostoy-microservice-79894f6945-cdmbd   1/1     Running   0          3m14s
ostoy-microservice-79894f6945-mgwk7   1/1     Running   0          4h24m
ostoy-microservice-79894f6945-q925d   1/1     Running   0          3m14s

ostoy-microservice-79894f6945-cdmbd   1/1     Running   0          3m14s
ostoy-microservice-79894f6945-mgwk7   1/1     Running   0          4h24m
ostoy-microservice-79894f6945-q925d   1/1     Running   0          3m14s

Copy to Clipboard

Toggle word wrap

You can also verify autoscaling from the OpenShift Cluster Manager
1. In the OpenShift web console navigational menu, click Observe > Dashboards.
2. In the dashboard, select Kubernetes / Compute Resources / Namespace (Pods) and your namespace ostoy.
  
  View larger image
3. A graph appears showing your resource usage across CPU and memory. The top graph shows recent CPU consumption per pod and the lower graph indicates memory usage. The following lists the callouts in the graph:
  1. The load increased (A).
  2. Two new pods were created (B and C).
  3. The thickness of each graph represents the CPU consumption and indicates which pods handled more load.
  4. The load decreased (D), and the pods were deleted.
    
    View larger image

2.7.3. Node autoscaling
Copia collegamento

Red Hat OpenShift Service on AWS allows you to use node autoscaling. In this scenario, you will create a new project with a job that has a large workload that the cluster cannot handle. With autoscaling enabled, when the load is larger than your current capacity, the cluster will automatically create new nodes to handle the load.

Prerequisites

Autoscaling is enabled on your machine pools.

Procedure

Create a new project called autoscale-ex by running the following command:
```
oc new-project autoscale-ex
```
```
$ oc new-project autoscale-ex
```
Copy to Clipboard Toggle word wrap

Create the job by running the following command:

oc create -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/job-work-queue.yaml

$ oc create -f https://raw.githubusercontent.com/openshift-cs/rosaworkshop/master/rosa-workshop/ostoy/yaml/job-work-queue.yaml

Copy to Clipboard

Toggle word wrap

After a few minuts, run the following command to see the pods:

oc get pods

$ oc get pods

Copy to Clipboard

Toggle word wrap

Example output

NAME                     READY   STATUS    RESTARTS   AGE
work-queue-5x2nq-24xxn   0/1     Pending   0          10s
work-queue-5x2nq-57zpt   0/1     Pending   0          10s
work-queue-5x2nq-58bvs   0/1     Pending   0          10s
work-queue-5x2nq-6c5tl   1/1     Running   0          10s
work-queue-5x2nq-7b84p   0/1     Pending   0          10s
work-queue-5x2nq-7hktm   0/1     Pending   0          10s
work-queue-5x2nq-7md52   0/1     Pending   0          10s
work-queue-5x2nq-7qgmp   0/1     Pending   0          10s
work-queue-5x2nq-8279r   0/1     Pending   0          10s
work-queue-5x2nq-8rkj2   0/1     Pending   0          10s
work-queue-5x2nq-96cdl   0/1     Pending   0          10s
work-queue-5x2nq-96tfr   0/1     Pending   0          10s

NAME                     READY   STATUS    RESTARTS   AGE
work-queue-5x2nq-24xxn   0/1     Pending   0          10s
work-queue-5x2nq-57zpt   0/1     Pending   0          10s
work-queue-5x2nq-58bvs   0/1     Pending   0          10s
work-queue-5x2nq-6c5tl   1/1     Running   0          10s
work-queue-5x2nq-7b84p   0/1     Pending   0          10s
work-queue-5x2nq-7hktm   0/1     Pending   0          10s
work-queue-5x2nq-7md52   0/1     Pending   0          10s
work-queue-5x2nq-7qgmp   0/1     Pending   0          10s
work-queue-5x2nq-8279r   0/1     Pending   0          10s
work-queue-5x2nq-8rkj2   0/1     Pending   0          10s
work-queue-5x2nq-96cdl   0/1     Pending   0          10s
work-queue-5x2nq-96tfr   0/1     Pending   0          10s

Copy to Clipboard

Toggle word wrap

Because there are many pods in a Pending state, this status triggers the autoscaler to create more nodes in your machine pool. Allow time to create these worker nodes.

After a few minutes, use the following command to see how many worker nodes you now have:

oc get nodes

$ oc get nodes

Copy to Clipboard

Toggle word wrap

Example output

NAME                                         STATUS   ROLES          AGE     VERSION
ip-10-0-138-106.us-west-2.compute.internal   Ready    infra,worker   22h     v1.23.5+3afdacb
ip-10-0-153-68.us-west-2.compute.internal    Ready    worker         2m12s   v1.23.5+3afdacb
ip-10-0-165-183.us-west-2.compute.internal   Ready    worker         2m8s    v1.23.5+3afdacb
ip-10-0-176-123.us-west-2.compute.internal   Ready    infra,worker   22h     v1.23.5+3afdacb
ip-10-0-195-210.us-west-2.compute.internal   Ready    master         23h     v1.23.5+3afdacb
ip-10-0-196-84.us-west-2.compute.internal    Ready    master         23h     v1.23.5+3afdacb
ip-10-0-203-104.us-west-2.compute.internal   Ready    worker         2m6s    v1.23.5+3afdacb
ip-10-0-217-202.us-west-2.compute.internal   Ready    master         23h     v1.23.5+3afdacb
ip-10-0-225-141.us-west-2.compute.internal   Ready    worker         23h     v1.23.5+3afdacb
ip-10-0-231-245.us-west-2.compute.internal   Ready    worker         2m11s   v1.23.5+3afdacb
ip-10-0-245-27.us-west-2.compute.internal    Ready    worker         2m8s    v1.23.5+3afdacb
ip-10-0-245-7.us-west-2.compute.internal     Ready    worker         23h     v1.23.5+3afdacb

NAME                                         STATUS   ROLES          AGE     VERSION
ip-10-0-138-106.us-west-2.compute.internal   Ready    infra,worker   22h     v1.23.5+3afdacb
ip-10-0-153-68.us-west-2.compute.internal    Ready    worker         2m12s   v1.23.5+3afdacb
ip-10-0-165-183.us-west-2.compute.internal   Ready    worker         2m8s    v1.23.5+3afdacb
ip-10-0-176-123.us-west-2.compute.internal   Ready    infra,worker   22h     v1.23.5+3afdacb
ip-10-0-195-210.us-west-2.compute.internal   Ready    master         23h     v1.23.5+3afdacb
ip-10-0-196-84.us-west-2.compute.internal    Ready    master         23h     v1.23.5+3afdacb
ip-10-0-203-104.us-west-2.compute.internal   Ready    worker         2m6s    v1.23.5+3afdacb
ip-10-0-217-202.us-west-2.compute.internal   Ready    master         23h     v1.23.5+3afdacb
ip-10-0-225-141.us-west-2.compute.internal   Ready    worker         23h     v1.23.5+3afdacb
ip-10-0-231-245.us-west-2.compute.internal   Ready    worker         2m11s   v1.23.5+3afdacb
ip-10-0-245-27.us-west-2.compute.internal    Ready    worker         2m8s    v1.23.5+3afdacb
ip-10-0-245-7.us-west-2.compute.internal     Ready    worker         23h     v1.23.5+3afdacb

Copy to Clipboard

Toggle word wrap

You can see the worker nodes were automatically created to handle the workload.

Return to the OSToy application by entering the following command:
```
oc project ostoy
```
```
$ oc project ostoy
```
Copy to Clipboard Toggle word wrap

2.8. S2I deployments
Copia collegamento

The integrated Source-to-Image (S2I) builder is one method to deploy applications in OpenShift. The S2I is a tool for building reproducible, Docker-formatted container images. For more information, see OpenShift concepts.

Prerequisites

A ROSA cluster

2.8.1. Retrieving your login command
Copia collegamento

Procedure

Confirm you are logged in to the command-line interface (CLI) by running the following command:
```
rosa whoami
```
```
rosa whoami
```
Copy to Clipboard Toggle word wrap
If you are logged in to the command-line interface, skip to "Creating a new project". If you are not logged in to the command-line interface, continue this procedure.
If you are not logged in to the command-line interface (CLI), in OpenShift Cluster Manager, click the dropdown arrow next to your name in the upper-right and select Copy Login Command.

View larger image
A new tab opens. Enter your username and password, and select the authentication method.
Click Display Token
Copy the command under "Log in with this token".

Example input

oc login --token=RYhFlXXXXXXXXXXXX --server=https://api.osd4-demo.abc1.p1.openshiftapps.com:6443

$ oc login --token=RYhFlXXXXXXXXXXXX --server=https://api.osd4-demo.abc1.p1.openshiftapps.com:6443

Copy to Clipboard

Toggle word wrap

Example output

Logged into "https://api.myrosacluster.abcd.p1.openshiftapps.com:6443" as "rosa-user" using the token provided.

You don't have any projects. You can try to create a new project, by running

oc new-project <project name>

Logged into "https://api.myrosacluster.abcd.p1.openshiftapps.com:6443" as "rosa-user" using the token provided.

You don't have any projects. You can try to create a new project, by running

oc new-project <project name>

Copy to Clipboard

Toggle word wrap

2.8.2. Creating a new project
Copia collegamento

Create a new project from the CLI by running the following command:
```
oc new-project ostoy-s2i
```
```
$ oc new-project ostoy-s2i
```
Copy to Clipboard Toggle word wrap

2.8.3. Fork the OSToy repository
Copia collegamento

In order to trigger automated builds based on changes to the source code, you must set up a GitHub webhook. The webhook will trigger S2I builds when you push code into your GitHub repository. To set up the webhook, you must first fork the repository.

Important

Replace <UserName> with your own GitHub username for the following URLs in this guide.

2.8.4. Using S2i to deploy OSToy on your cluster
Copia collegamento

Procedure

Add a secret to OpenShift.
This example emulates a .env file. Files are easily moved directly into an OpenShift environment and can even be renamed in the secret.
- Run the following command, replacing <UserName> with your GitHub username:
  $ oc create -f https://raw.githubusercontent.com/<UserName>/ostoy/master/deployment/yaml/secret.yaml
  Copy to Clipboard Toggle word wrap
Add a ConfigMap to OpenShift.
This example emulates an HAProxy config file, which is typically used for overriding default configurations in an OpenShift application. Files can be renamed in the ConfigMap.
- Run the following command, replacing <UserName> with your GitHub username:
  $ oc create -f https://raw.githubusercontent.com/<UserName>/ostoy/master/deployment/yaml/configmap.yaml
  Copy to Clipboard Toggle word wrap

Deploy the microservice.

You must deploy the microservice to ensure that the service environment variables are available from the UI application.

--context-dir builds the application defined in the microservice directory in the Git repository. The app label ensures the user interface (UI) application and microservice are both grouped in the OpenShift UI.

Run the following command to create the microservice, replacing <UserName> with your GitHub username:

oc new-app https://github.com/<UserName>/ostoy \
    --context-dir=microservice \
    --name=ostoy-microservice \
    --labels=app=ostoy

$ oc new-app https://github.com/<UserName>/ostoy \
    --context-dir=microservice \
    --name=ostoy-microservice \
    --labels=app=ostoy

Copy to Clipboard

Toggle word wrap

Example output

--> Creating resources with label app=ostoy ...
    imagestream.image.openshift.io "ostoy-microservice" created
    buildconfig.build.openshift.io "ostoy-microservice" created
    deployment.apps "ostoy-microservice" created
    service "ostoy-microservice" created
--> Success
    Build scheduled, use 'oc logs -f buildconfig/ostoy-microservice' to track its progress.
    Application is not exposed. You can expose services to the outside world by executing one or more of the commands below:
     'oc expose service/ostoy-microservice'
    Run 'oc status' to view your app.

--> Creating resources with label app=ostoy ...
    imagestream.image.openshift.io "ostoy-microservice" created
    buildconfig.build.openshift.io "ostoy-microservice" created
    deployment.apps "ostoy-microservice" created
    service "ostoy-microservice" created
--> Success
    Build scheduled, use 'oc logs -f buildconfig/ostoy-microservice' to track its progress.
    Application is not exposed. You can expose services to the outside world by executing one or more of the commands below:
     'oc expose service/ostoy-microservice'
    Run 'oc status' to view your app.

Copy to Clipboard

Toggle word wrap

Check the status of the microservice.

Check that the microservice was created and is running correctly by running the following command:

oc status

$ oc status

Copy to Clipboard

Toggle word wrap

Example output

In project ostoy-s2i on server https://api.myrosacluster.g14t.p1.openshiftapps.com:6443

svc/ostoy-microservice - 172.30.47.74:8080
  dc/ostoy-microservice deploys istag/ostoy-microservice:latest <-
    bc/ostoy-microservice source builds https://github.com/UserName/ostoy on openshift/nodejs:14-ubi8
    deployment #1 deployed 34 seconds ago - 1 pod

In project ostoy-s2i on server https://api.myrosacluster.g14t.p1.openshiftapps.com:6443

svc/ostoy-microservice - 172.30.47.74:8080
  dc/ostoy-microservice deploys istag/ostoy-microservice:latest <-
    bc/ostoy-microservice source builds https://github.com/UserName/ostoy on openshift/nodejs:14-ubi8
    deployment #1 deployed 34 seconds ago - 1 pod

Copy to Clipboard

Toggle word wrap

Wait until you see that the microservice was successfully deployed. You can also check this through the web UI.

Deploy the front end UI.

The application relies on several environment variables to define external settings.

Attach the secret and ConfigMap and create a PersistentVolume by running the following command:

oc new-app https://github.com/<UserName>/ostoy \
    --env=MICROSERVICE_NAME=OSTOY_MICROSERVICE

$ oc new-app https://github.com/<UserName>/ostoy \
    --env=MICROSERVICE_NAME=OSTOY_MICROSERVICE

Copy to Clipboard

Toggle word wrap

Example output

--> Creating resources ...
    imagestream.image.openshift.io "ostoy" created
    buildconfig.build.openshift.io "ostoy" created
    deployment.apps "ostoy" created
    service "ostoy" created
--> Success
    Build scheduled, use 'oc logs -f buildconfig/ostoy' to track its progress.
    Application is not exposed. You can expose services to the outside world by executing one or more of the commands below:
     'oc expose service/ostoy'
    Run 'oc status' to view your app.

--> Creating resources ...
    imagestream.image.openshift.io "ostoy" created
    buildconfig.build.openshift.io "ostoy" created
    deployment.apps "ostoy" created
    service "ostoy" created
--> Success
    Build scheduled, use 'oc logs -f buildconfig/ostoy' to track its progress.
    Application is not exposed. You can expose services to the outside world by executing one or more of the commands below:
     'oc expose service/ostoy'
    Run 'oc status' to view your app.

Copy to Clipboard

Toggle word wrap

Update the deployment by running the following command:

oc patch deployment ostoy --type=json -p \
    '[{"op": "replace", "path": "/spec/strategy/type", "value": "Recreate"}, {"op": "remove", "path": "/spec/strategy/rollingUpdate"}]'

$ oc patch deployment ostoy --type=json -p \
    '[{"op": "replace", "path": "/spec/strategy/type", "value": "Recreate"}, {"op": "remove", "path": "/spec/strategy/rollingUpdate"}]'

Copy to Clipboard

Toggle word wrap

Set a liveness probe.
Create a liveness probe to ensure the pod restarts if something is wrong in the application.
- Run the following command:
  $ oc set probe deployment ostoy --liveness --get-url=http://:8080/health
  Copy to Clipboard Toggle word wrap

Attach the secret, ConfigMap, and persistent volume to the deployment.

Run the following command to attach your secret:

oc set volume deployment ostoy --add \
    --secret-name=ostoy-secret \
    --mount-path=/var/secret

$ oc set volume deployment ostoy --add \
    --secret-name=ostoy-secret \
    --mount-path=/var/secret

Copy to Clipboard

Toggle word wrap

Run the following command to attach your ConfigMap:

oc set volume deployment ostoy --add \
    --configmap-name=ostoy-config \
    -m /var/config

$ oc set volume deployment ostoy --add \
    --configmap-name=ostoy-config \
    -m /var/config

Copy to Clipboard

Toggle word wrap

Run the following command to create and attach your persistent volume:

oc set volume deployment ostoy --add \
    --type=pvc \
    --claim-size=1G \
    -m /var/demo_files

$ oc set volume deployment ostoy --add \
    --type=pvc \
    --claim-size=1G \
    -m /var/demo_files

Copy to Clipboard

Toggle word wrap

Expose the UI application as an OpenShift Route.
- Run the following command to deploy the application as an HTTPS application that uses the included TLS wildcard certificates:
  $ oc create route edge --service=ostoy --insecure-policy=Redirect
  Copy to Clipboard Toggle word wrap
Browse to your application with the following methods:
- Run the following command to open a web browser with your OSToy application:
  $ python -m webbrowser "$(oc get route ostoy -o template --template='https://{{.spec.host}}')"
  Copy to Clipboard Toggle word wrap
- Run the following command to get the route for the application and copy and paste the route into your browser:
  $ oc get route
  Copy to Clipboard Toggle word wrap

2.9. Using Source-to-Image (S2I) webhooks for automated deployment
Copia collegamento

Automatically trigger a build and deploy any time you change the source code by using a webhook. For more information about this process, see Triggering Builds.

Procedure

Obtain the GitHub webhook trigger secret by running the following command:
```
oc get bc/ostoy-microservice -o=jsonpath='{.spec.triggers..github.secret}'
```
```
$ oc get bc/ostoy-microservice -o=jsonpath='{.spec.triggers..github.secret}'
```
Copy to Clipboard Toggle word wrap
Example output
```
`o_3x9M1qoI2Wj_cz1WiK`
```
```
`o_3x9M1qoI2Wj_cz1WiK`
```
Copy to Clipboard Toggle word wrap
Important
You need to use this secret in a later step in this process.

Obtain the GitHub webhook trigger URL from the OSToy’s buildconfig by running the following command:

oc describe bc/ostoy-microservice

$ oc describe bc/ostoy-microservice

Copy to Clipboard

Toggle word wrap

Example output

[...]
Webhook GitHub:
	URL:	https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy/webhooks/<secret>/github
[...]

[...]
Webhook GitHub:
	URL:	https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy/webhooks/<secret>/github
[...]

Copy to Clipboard

Toggle word wrap

In the GitHub webhook URL, replace the <secret> text with the secret you retrieved. Your URL will resemble the following example output:

Example output

https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy-microservice/webhooks/o_3x9M1qoI2Wj_czR1WiK/github

https://api.demo1234.openshift.com:443/apis/build.openshift.io/v1/namespaces/ostoy-s2i/buildconfigs/ostoy-microservice/webhooks/o_3x9M1qoI2Wj_czR1WiK/github

Copy to Clipboard

Toggle word wrap

Set up the webhook URL in GitHub repository.
1. In your repository, click Settings > Webhooks > Add webhook.
  
  View larger image
2. Paste the GitHub webhook URL with the Secret included in the "Payload URL" field.
3. Change the "Content type" to application/json.
4. Click the Add webhook button.
  
  View larger image
  
  You should see a message from GitHub stating that your webhook was successfully configured. Now, whenever you push a change to your GitHub repository, a new build automatically starts, and upon a successful build, a new deployment starts.
Make a change in the source code. Any changes automatically trigger a build and deployment. In this example, the colors that denote the status of your OSToy app are randomly selected. To test the configuration, change the box to display grayscale.
1. Go to the source code in your repository https://github.com/<username>/ostoy/blob/master/microservice/app.js.
2. Edit the file.
3. Comment out line 8 (containing let randomColor = getRandomColor();).
4. Uncomment line 9 (containing let randomColor = getRandomGrayScaleColor();).
  7 app.get('/', function(request, response) { 8 //let randomColor = getRandomColor(); // <-- comment this 9 let randomColor = getRandomGrayScaleColor(); // <-- uncomment this 10 11 response.writeHead(200, {'Content-Type': 'application/json'});
  Copy to Clipboard Toggle word wrap
5. Enter a message for the update, such as "changed box to grayscale colors".
6. Click Commit at the bottom to commit the changes to the main branch.
In your cluster’s web UI, click Builds > Builds to determine the status of the build. After this build is completed, the deployment begins. You can also check the status by running oc status in your terminal.

View larger image
After the deployment has finished, return to the OSToy application in your browser. Access the Networking menu item on the left. The box color is now limited to grayscale colors only.

View larger image

Questo contenuto non è disponibile nella lingua selezionata.

Chapter 2. Deploying an application workshop

2.1. Workshop overviewCopia collegamentoCollegamento copiato negli appunti!

2.1.1. IntroductionCopia collegamentoCollegamento copiato negli appunti!

2.1.2. About the OSToy applicationCopia collegamentoCollegamento copiato negli appunti!

2.1.2.1. OSToy application diagramCopia collegamentoCollegamento copiato negli appunti!

2.1.2.2. Understanding the OSToy UICopia collegamentoCollegamento copiato negli appunti!

2.1.2.3. Lab resourcesCopia collegamentoCollegamento copiato negli appunti!

2.2. Deploying the OSToy application with KubernetesCopia collegamentoCollegamento copiato negli appunti!

2.2.1. Retrieving the login commandCopia collegamentoCollegamento copiato negli appunti!

2.2.2. Creating a new projectCopia collegamentoCollegamento copiato negli appunti!

2.2.2.1. Creating a new project using the CLICopia collegamentoCollegamento copiato negli appunti!

2.2.2.2. Creating a new project using the web consoleCopia collegamentoCollegamento copiato negli appunti!

2.2.3. Deploying the back-end microserviceCopia collegamentoCollegamento copiato negli appunti!

2.2.4. Deploying the front-end microserviceCopia collegamentoCollegamento copiato negli appunti!

2.2.5. Obtain the route to your applicationCopia collegamentoCollegamento copiato negli appunti!

2.2.6. Viewing the applicationCopia collegamentoCollegamento copiato negli appunti!

2.3. Health checkCopia collegamentoCollegamento copiato negli appunti!

2.3.1. Preparing your desktopCopia collegamentoCollegamento copiato negli appunti!

2.3.2. Crashing the podCopia collegamentoCollegamento copiato negli appunti!

2.3.3. Viewing the revived podCopia collegamentoCollegamento copiato negli appunti!

2.3.4. Making the application malfunctionCopia collegamentoCollegamento copiato negli appunti!

2.4. Persistent volumes for cluster storageCopia collegamentoCollegamento copiato negli appunti!

2.4.1. Using persistent volumesCopia collegamentoCollegamento copiato negli appunti!

2.4.1.1. Viewing a persistent volume claimCopia collegamentoCollegamento copiato negli appunti!

2.4.1.2. Storing your fileCopia collegamentoCollegamento copiato negli appunti!

2.4.1.3. Crashing the podCopia collegamentoCollegamento copiato negli appunti!

2.4.1.4. Confirming persistent storageCopia collegamentoCollegamento copiato negli appunti!

2.4.1.5. Ending the sessionCopia collegamentoCollegamento copiato negli appunti!

2.5. ConfigMaps, secrets, and environment variablesCopia collegamentoCollegamento copiato negli appunti!

2.5.1. Configuration using ConfigMapsCopia collegamentoCollegamento copiato negli appunti!

2.5.2. Configuration using secretsCopia collegamentoCollegamento copiato negli appunti!

2.5.3. Configuration using environment variablesCopia collegamentoCollegamento copiato negli appunti!

2.6. NetworkingCopia collegamentoCollegamento copiato negli appunti!

2.6.1. Intra-cluster networkingCopia collegamentoCollegamento copiato negli appunti!

2.7. Scaling an applicationCopia collegamentoCollegamento copiato negli appunti!

2.7.1. Manual pod scalingCopia collegamentoCollegamento copiato negli appunti!

2.7.2. Pod autoscalingCopia collegamentoCollegamento copiato negli appunti!

2.7.3. Node autoscalingCopia collegamentoCollegamento copiato negli appunti!

2.8. S2I deploymentsCopia collegamentoCollegamento copiato negli appunti!

2.8.1. Retrieving your login commandCopia collegamentoCollegamento copiato negli appunti!

2.8.2. Creating a new projectCopia collegamentoCollegamento copiato negli appunti!

2.8.3. Fork the OSToy repositoryCopia collegamentoCollegamento copiato negli appunti!

2.8.4. Using S2i to deploy OSToy on your clusterCopia collegamentoCollegamento copiato negli appunti!

2.9. Using Source-to-Image (S2I) webhooks for automated deploymentCopia collegamentoCollegamento copiato negli appunti!

Formazione

Prova, acquista e vendi

Community

Informazioni sulla documentazione di Red Hat

Rendiamo l’open source più inclusivo

Informazioni su Red Hat

Theme

Red Hat legal and privacy links

Red Hat legal and privacy links

2.1. Workshop overview
Copia collegamento

2.1.1. Introduction
Copia collegamento

2.1.2. About the OSToy application
Copia collegamento

2.1.2.1. OSToy application diagram
Copia collegamento

2.1.2.2. Understanding the OSToy UI
Copia collegamento

2.1.2.3. Lab resources
Copia collegamento

2.2. Deploying the OSToy application with Kubernetes
Copia collegamento

2.2.1. Retrieving the login command
Copia collegamento

2.2.2. Creating a new project
Copia collegamento

2.2.2.1. Creating a new project using the CLI
Copia collegamento

2.2.2.2. Creating a new project using the web console
Copia collegamento

2.2.3. Deploying the back-end microservice
Copia collegamento

2.2.4. Deploying the front-end microservice
Copia collegamento

2.2.5. Obtain the route to your application
Copia collegamento

2.2.6. Viewing the application
Copia collegamento

2.3. Health check
Copia collegamento

2.3.1. Preparing your desktop
Copia collegamento

2.3.2. Crashing the pod
Copia collegamento

2.3.3. Viewing the revived pod
Copia collegamento

2.3.4. Making the application malfunction
Copia collegamento

2.4. Persistent volumes for cluster storage
Copia collegamento

2.4.1. Using persistent volumes
Copia collegamento

2.4.1.1. Viewing a persistent volume claim
Copia collegamento

2.4.1.2. Storing your file
Copia collegamento

2.4.1.3. Crashing the pod
Copia collegamento

2.4.1.4. Confirming persistent storage
Copia collegamento

2.4.1.5. Ending the session
Copia collegamento

2.5. ConfigMaps, secrets, and environment variables
Copia collegamento

2.5.1. Configuration using ConfigMaps
Copia collegamento

2.5.2. Configuration using secrets
Copia collegamento

2.5.3. Configuration using environment variables
Copia collegamento

2.6. Networking
Copia collegamento

2.6.1. Intra-cluster networking
Copia collegamento

2.7. Scaling an application
Copia collegamento

2.7.1. Manual pod scaling
Copia collegamento

2.7.2. Pod autoscaling
Copia collegamento

2.7.3. Node autoscaling
Copia collegamento

2.8. S2I deployments
Copia collegamento

2.8.1. Retrieving your login command
Copia collegamento

2.8.2. Creating a new project
Copia collegamento

2.8.3. Fork the OSToy repository
Copia collegamento

2.8.4. Using S2i to deploy OSToy on your cluster
Copia collegamento

2.9. Using Source-to-Image (S2I) webhooks for automated deployment
Copia collegamento