CLI tools

You can install the OpenShift CLI (oc) to interact with OpenShift Container Platform from a command-line interface. You can install oc on Linux, Windows, or macOS.

$ oc <command>

C:\> oc <command>

$ oc <command>

You can install the OpenShift CLI (oc) to interact with OpenShift Container Platform from a web console. You can install oc on Linux, Windows, or macOS.

$ oc <command>

C:\> oc <command>

$ oc <command>

For Red Hat Enterprise Linux (RHEL), you can install the OpenShift CLI (oc) as an RPM if you have an active OpenShift Container Platform subscription on your Red Hat account.

After you install the CLI, it is available using the oc command:

$ oc <command>

For macOS, you can install the OpenShift CLI (oc) by using the Homebrew package manager.

Use the oc new-project command to create a new project.

$ oc new-project my-project

Now using project "my-project" on server "https://openshift.example.com:6443".

Use the oc new-app command to create a new application.

$ oc new-app https://github.com/sclorg/cakephp-ex

--> Found image 40de956 (9 days old) in imagestream "openshift/php" under tag "7.2" for "php"

...

    Run 'oc status' to view your app.

Use the oc get pods command to view the pods for the current project.

$ oc get pods -o wide

NAME                  READY   STATUS      RESTARTS   AGE     IP            NODE                           NOMINATED NODE
cakephp-ex-1-build    0/1     Completed   0          5m45s   10.131.0.10   ip-10-0-141-74.ec2.internal    <none>
cakephp-ex-1-deploy   0/1     Completed   0          3m44s   10.129.2.9    ip-10-0-147-65.ec2.internal    <none>
cakephp-ex-1-ktz97    1/1     Running     0          3m33s   10.128.2.11   ip-10-0-168-105.ec2.internal   <none>

Use the oc logs command to view logs for a particular pod.

$ oc logs cakephp-ex-1-deploy

--> Scaling cakephp-ex-1 to 1
--> Success

Use the oc project command to view the current project.

$ oc project

Using project "my-project" on server "https://openshift.example.com:6443".

Use the oc status command to view information about the current project, such as services, deployments, and build configs.

$ oc status

In project my-project on server https://openshift.example.com:6443

svc/cakephp-ex - 172.30.236.80 ports 8080, 8443
  dc/cakephp-ex deploys istag/cakephp-ex:latest <-
    bc/cakephp-ex source builds https://github.com/sclorg/cakephp-ex on openshift/php:7.2
    deployment #1 deployed 2 minutes ago - 1 pod

3 infos identified, use 'oc status --suggest' to see details.

Use the oc api-resources command to view the list of supported API resources on the server.

$ oc api-resources

NAME                                  SHORTNAMES       APIGROUP                              NAMESPACED   KIND
bindings                                                                                     true         Binding
componentstatuses                     cs                                                     false        ComponentStatus
configmaps                            cm                                                     true         ConfigMap
...

After you install the OpenShift CLI (oc), you can enable tab completion to automatically complete oc commands or suggest options when you press Tab. The following procedure enables tab completion for the Bash shell.

Tab completion is enabled when you open a new terminal.

After you install the OpenShift CLI (oc), you can enable tab completion to automatically complete oc commands or suggest options when you press Tab. The following procedure enables tab completion for the Zsh shell.

Tab completion is enabled when you open a new terminal.

Display documentation for a certain resource.

$ oc explain pods

Log in to the OpenShift Container Platform server and save login information for subsequent use.

$ oc login -u user1

Create a new application by specifying source code, a template, or an image.

$ oc new-app .

$ oc new-app https://github.com/sclorg/cakephp-ex

$ oc new-app https://github.com/youruser/yourprivaterepo --source-secret=yoursecret

Create a new project and switch to it as the default project in your configuration.

$ oc new-project myproject

Switch to another project and make it the default in your configuration.

$ oc project test-project

Display information about the current active project and existing projects on the server.

$ oc projects

Show a high-level overview of the current project.

$ oc status

Cancel a running, pending, or new build.

$ oc cancel-build python-1

$ oc cancel-build buildconfig/python --state=pending

Import the latest tag and image information from an image repository.

$ oc import-image my-ruby

Create a new build config from source code.

$ oc new-build .

$ oc new-build https://github.com/sclorg/cakephp-ex

Revert an application back to a previous deployment.

$ oc rollback php

$ oc rollback php --to-version=3

Start a new rollout, view its status or history, or roll back to a previous revision of your application.

$ oc rollout undo deploymentconfig/php

$ oc rollout latest deploymentconfig/php

Start a build from a build config or copy an existing build.

$ oc start-build python

$ oc start-build --from-build=python-1

$ oc start-build python --env=mykey=myvalue

Tag existing images into image streams.

$ oc tag ruby:latest ruby:2.0

Update the annotations on one or more resources.

$ oc annotate route/test-route haproxy.router.openshift.io/ip_whitelist="192.168.1.10"

$ oc annotate route/test-route haproxy.router.openshift.io/ip_whitelist-

Apply a configuration to a resource by file name or standard in (stdin) in JSON or YAML format.

$ oc apply -f pod.json

Autoscale a deployment or replication controller.

$ oc autoscale deploymentconfig/parksmap-katacoda --min=2 --max=5

Create a resource by file name or standard in (stdin) in JSON or YAML format.

$ oc create -f pod.json

Delete a resource.

$ oc delete pod/parksmap-katacoda-1-qfqz4

$ oc delete pods -l app=parksmap-katacoda

Return detailed information about a specific object.

$ oc describe deployment/example

$ oc describe pods

Edit a resource.

$ oc edit deploymentconfig/parksmap-katacoda

$ OC_EDITOR="nano" oc edit deploymentconfig/parksmap-katacoda

$ oc edit deploymentconfig/parksmap-katacoda -o json

Expose a service externally as a route.

$ oc expose service/parksmap-katacoda

$ oc expose service/parksmap-katacoda --hostname=www.my-host.com

Display one or more resources.

$ oc get pods -n default

$ oc get deploymentconfig/python -o json

Update the labels on one or more resources.

$ oc label pod/python-1-mz2rf status=unhealthy

Set the desired number of replicas for a replication controller or a deployment.

$ oc scale deploymentconfig/ruby-app --replicas=3

Manage secrets in your project.

$ oc secrets link default my-pull-secret --for=pull

Get a token assigned to a service account or create a new token or kubeconfig file for a service account.

$ oc serviceaccounts get-token default

Configure existing application resources.

$ oc set build-secret --source buildconfig/mybc mysecret

Attach the shell to a running container.

$ oc attach python-1-mz2rf -c python

Copy files and directories to and from containers.

$ oc cp default/python-1-mz2rf:/opt/app-root/src/README.md ~/mydirectory/.

Launch a command shell to debug a running application.

$ oc debug deploymentconfig/python

Execute a command in a container.

$ oc exec python-1-mz2rf -c python ls

Retrieve the log output for a specific build, build config, deployment, or pod.

$ oc logs -f deploymentconfig/python

Forward one or more local ports to a pod.

$ oc port-forward python-1-mz2rf 8888:5000

Run a proxy to the Kubernetes API server.

$ oc proxy --port=8011 --www=./local/www/

Open a remote shell session to a container.

$ oc rsh python-1-mz2rf

Copy contents of a directory to or from a running pod container. Only changed files are copied using the rsync command from your operating system.

$ oc rsync ~/mydirectory/ python-1-mz2rf:/opt/app-root/src/

Create a pod running a particular image.

$ oc run my-test --image=perl

Wait for a specific condition on one or more resources.

$ oc wait --for=delete pod/python-1-mz2rf

Display the full list of API resources that the server supports.

$ oc api-resources

Display the full list of API versions that the server supports.

$ oc api-versions

Inspect permissions and reconcile RBAC roles.

$ oc auth can-i get pods --subresource=log

$ oc auth reconcile -f policy.json

Display the address of the master and cluster services.

$ oc cluster-info

Extract the contents of a config map or secret. Each key in the config map or secret is created as a separate file with the name of the key.

$ oc extract configmap/ruby-1-ca

$ oc extract configmap/ruby-1-ca --to=-

Idle scalable resources. An idled service will automatically become unidled when it receives traffic or it can be manually unidled using the oc scale command.

$ oc idle ruby-app

Manage images in your OpenShift Container Platform cluster.

$ oc image mirror myregistry.com/myimage:latest myregistry.com/myimage:stable

Observe changes to resources and take action on them.

$ oc observe services

Updates one or more fields of an object using strategic merge patch in JSON or YAML format.

$ oc patch node/node1 -p '{"spec":{"unschedulable":true}}'

Manage authorization policies.

$ oc policy add-role-to-user edit user1

Process a template into a list of resources.

$ oc process -f template.json | oc create -f -

Manage the integrated registry on OpenShift Container Platform.

$ oc registry info

Modify an existing object based on the contents of the specified configuration file.

$ oc replace -f pod.json

Output shell completion code for the specified shell.

$ oc completion bash

Manage the client configuration files.

$ oc config view

$ oc config use-context test-context

Log out of the current session.

$ oc logout

Display information about the current session.

$ oc whoami

Display general help information for the CLI and a list of available commands.

$ oc help

$ oc help new-project

List the available plug-ins on the user’s PATH.

$ oc plugin list

Display the oc client and server versions.

$ oc version

For cluster administrators, the OpenShift Container Platform server version is also displayed.

Gather debugging information for a particular resource.

$ oc adm inspect clusteroperator/openshift-apiserver

Bulk collect data about the current state of your cluster to debug issues.

$ oc adm must-gather

Show usage statistics of resources on the server.

$ oc adm top pods

$ oc adm top images

Mark a node as unschedulable. Manually marking a node as unschedulable blocks any new pods from being scheduled on the node, but does not affect existing pods on the node.

$ oc adm cordon node1

Drain a node in preparation for maintenance.

$ oc adm drain node1

Display and filter node logs.

$ oc adm node-logs --role master -u NetworkManager.service

Update the taints on one or more nodes.

$ oc adm taint nodes node1 dedicated=groupName:NoSchedule

$ oc adm taint nodes node1 dedicated-

Mark a node as schedulable.

$ oc adm uncordon node1

Approve or reject certificate signing requests (CSRs).

$ oc adm certificate approve csr-sqgzp

Manage groups in your cluster.

$ oc adm groups new my-group

Create a new project and specify administrative options.

$ oc adm new-project myproject --node-selector='type=user-node,region=east'

Manage pod networks in the cluster.

$ oc adm pod-network isolate-projects project1 project2

Manage roles and policies on the cluster.

$ oc adm policy add-cluster-role-to-user edit user1

$ oc adm policy add-scc-to-user privileged -z myserviceaccount

Migrate resources on the cluster to a new version or format depending on the subcommand used.

$ oc adm migrate storage

$ oc adm migrate storage --include=pods

Remove older versions of resources from the server.

$ oc adm prune builds --orphans

Create a bootstrap project template.

$ oc adm create-bootstrap-project-template -o yaml

Create a template for customizing the error page.

$ oc adm create-error-template

Creates a basic .kubeconfig file from client certificates.

$ oc adm create-kubeconfig \
  --client-certificate=/path/to/client.crt \
  --client-key=/path/to/client.key \
  --certificate-authority=/path/to/ca.crt

Create a template for customizing the login page.

$ oc adm create-login-template

Create a template for customizing the provider selection page.

$ oc adm create-provider-selection-template

Output the inputs and dependencies of any builds.

$ oc adm build-chain perl

Output shell completion code for the oc adm commands for the specified shell.

$ oc adm completion bash

Manage the client configuration files. This command has the same behavior as the oc config command.

$ oc adm config view

$ oc adm config use-context test-context

Manage various aspects of the OpenShift Container Platform release process, such as viewing information about a release or inspecting the contents of a release.

$ oc adm release info --changelog=/tmp/git \
    quay.io/openshift-release-dev/ocp-release:4.7.0-x86_64 \
    quay.io/openshift-release-dev/ocp-release:4.7.1-x86_64 \
    > changelog.md

Verify the image signature of an image imported to the internal registry using the local public GPG key.

$ oc adm verify-image-signature \
    sha256:2bba968aedb7dd2aafe5fa8c7453f5ac36a0b9639f1bf5b03f95de325238b288 \
    --expected-identity 172.30.1.1:5000/openshift/nodejs:latest \
    --public-key /etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release \
    --save

odo uses the portable devfile format to describe the components. It can connect to various devfile registries to download devfiles for different languages and frameworks. See odo registry for more information.

$ odo catalog list components

 NAME             DESCRIPTION                          REGISTRY
 go               Stack with the latest Go version     DefaultDevfileRegistry
 java-maven       Upstream Maven and OpenJDK 11        DefaultDevfileRegistry
 nodejs           Stack with Node.js 14                DefaultDevfileRegistry
 php-laravel      Stack with Laravel 8                 DefaultDevfileRegistry
 python           Python Stack with Python 3.7         DefaultDevfileRegistry
 [...]

$ odo catalog describe component

$ odo catalog describe component nodejs

* Registry: DefaultDevfileRegistry <.>

Starter Projects: <.>
---
name: nodejs-starter
attributes: {}
description: ""
subdir: ""
projectsource:
  sourcetype: ""
  git:
    gitlikeprojectsource:
      commonprojectsource: {}
      checkoutfrom: null
      remotes:
        origin: https://github.com/odo-devfiles/nodejs-ex.git
  zip: null
  custom: null

odo can deploy services with the help of Operators.

Only Operators deployed with the help of the Operator Lifecycle Manager are supported by odo.

$ odo catalog list services

 Services available through Operators
 NAME                                 CRDs
 postgresql-operator.v0.1.1           Backup, Database
 redis-operator.v0.8.0                RedisCluster, Redis

$ odo catalog search service

$ odo catalog search service postgres

 Services available through Operators
 NAME                           CRDs
 postgresql-operator.v0.1.1     Backup, Database

$ odo catalog describe service

$ odo catalog describe service postgresql-operator.v0.1.1/Database

KIND:    Database
VERSION: v1alpha1

DESCRIPTION:
     Database is the Schema for the the Database Database API

FIELDS:
   awsAccessKeyId (string)
     AWS S3 accessKey/token ID

     Key ID of AWS S3 storage. Default Value: nil Required to create the Secret
     with the data to allow send the backup files to AWS S3 storage.
[...]

$ odo catalog describe service redis-operator.v0.8.0

NAME:	redis-operator.v0.8.0
DESCRIPTION:

	A Golang based redis operator that will make/oversee Redis
	standalone/cluster mode setup on top of the Kubernetes. It can create a
	redis cluster setup with best practices on Cloud as well as the Bare metal
	environment. Also, it provides an in-built monitoring capability using

... (cut short for beverity)

	Logging Operator is licensed under [Apache License, Version
	2.0](https://github.com/OT-CONTAINER-KIT/redis-operator/blob/master/LICENSE)


CRDs:
	NAME           DESCRIPTION
	RedisCluster   Redis Cluster
	Redis          Redis

To create a devfile for an existing project, run the odo create command with the name and type of your component (for example, nodejs or go):

odo create nodejs mynodejs

In the example, nodejs is the type of the component and mynodejs is the name of the component that odo creates for you.

If your source code exists outside the current directory, the --context flag can be used to specify the path. For example, if the source for the nodejs component is in a folder called node-backend relative to the current working directory, run the command:

odo create nodejs mynodejs --context ./node-backend

The --context flag supports relative and absolute paths.

To specify the project or app where your component will be deployed, use the --project and --app flags. For example, to create a component that is part of the myapp app inside the backend project, run the command:

odo create nodejs --app myapp --project backend

Use the starter projects if you do not have existing source code but want to get up and running quickly to experiment with devfiles and components. To use a starter project, add the --starter flag to the odo create command.

To get a list of available starter projects for a component type, run the odo catalog describe component command. For example, to get all available starter projects for the nodejs component type, run the command:

odo catalog describe component nodejs

Then specify the desired project using the --starter flag on the odo create command:

odo create nodejs --starter nodejs-starter

This will download the example template corresponding to the chosen component type, in this instance, nodejs. The template is downloaded to your current directory, or to the location specified by the --context flag. If a starter project has its own devfile, then this devfile will be preserved.

If you want to create a new component from an existing devfile, you can do so by specifying the path to the devfile using the --devfile flag. For example, to create a component called mynodejs, based on a devfile from GitHub, use the following command:

odo create mynodejs --devfile https://raw.githubusercontent.com/odo-devfiles/registry/master/devfiles/nodejs/devfile.yaml

You can also run the odo create command interactively, to guide you through the steps needed to create a component:

$ odo create

? Which devfile component type do you wish to create go
? What do you wish to name the new devfile component go-api
? What project do you want the devfile component to be created in default
Devfile Object Validation
 ✓  Checking devfile existence [164258ns]
 ✓  Creating a devfile component from registry: DefaultDevfileRegistry [246051ns]
Validation
 ✓  Validating if devfile name is correct [92255ns]
? Do you want to download a starter project Yes

Starter Project
 ✓  Downloading starter project go-starter from https://github.com/devfile-samples/devfile-stack-go.git [429ms]

Please use odo push command to create the component with source deployed

You are prompted to choose the component type, name, and the project for the component. You can also choose whether or not to download a starter project. Once finished, a new devfile.yaml file is created in the working directory.

To deploy these resources to your cluster, run the command odo push.

To delete a devfile component, run the odo delete command:

$ odo delete

If the component has been pushed to the cluster, the component is deleted from the cluster, along with its dependent storage, URL, secrets, and other resources. If the component has not been pushed, the command exits with an error stating that it could not find the resources on the cluster.

Use the -f or --force flag to avoid the confirmation questions.

To undeploy the devfile Kubernetes components, that have been deployed with odo deploy, execute the odo delete command with the --deploy flag:

$ odo delete --deploy

Use the -f or --force flag to avoid the confirmation questions.

To delete all artifacts including the following items, run the odo delete command with the --all flag :

$ odo delete --all

The documentation on Common Flags provides more information on the flags available for commands.

odo provides various options for linking a component with an Operator-backed service or another odo component. All these options (or flags) can be used whether you are linking a component to a service or to another component.

Another helpful flag that odo link provides is --bind-as-files. When this flag is passed, the binding information is not injected into the component’s Pod as environment variables but is mounted as a filesystem.

Ensure that there are no existing links between the backend component and the PostgreSQL service. You could do this by running odo describe in the backend component’s directory and check if you see output similar to the following:

Linked Services:
 · PostgresCluster/hippo

Unlink the service from the component using:

$ odo unlink PostgresCluster/hippo
$ odo push

To list the registries currently contacted by odo, run the command:

$ odo registry list

NAME                       URL                             SECURE
DefaultDevfileRegistry     https://registry.devfile.io     No

DefaultDevfileRegistry is the default registry used by odo; it is provided by the devfile.io project.

To add a registry, run the command:

$ odo registry add

$ odo registry add StageRegistry https://registry.stage.devfile.io
New registry successfully added

If you are deploying your own Secure Registry, you can specify the personal access token to authenticate to the secure registry with the --token flag:

$ odo registry add MyRegistry https://myregistry.example.com --token <access_token>
New registry successfully added

To delete a registry, run the command:

$ odo registry delete

$ odo registry delete StageRegistry
? Are you sure you want to delete registry "StageRegistry" Yes
Successfully deleted registry

Use the --force (or -f) flag to force the deletion of the registry without confirmation.

To update the URL or the personal access token of a registry already registered, run the command:

$ odo registry update

 $ odo registry update MyRegistry https://otherregistry.example.com --token <other_access_token>
 ? Are you sure you want to update registry "MyRegistry" Yes
 Successfully updated registry

Use the --force (or -f) flag to force the update of the registry without confirmation.

To create a new service, run the command:

$ odo service create

For example, to create an instance of a Redis service named my-redis-service, you can run the following command:

$ odo catalog list services
Services available through Operators
NAME                      CRDs
redis-operator.v0.8.0     RedisCluster, Redis

$ odo service create redis-operator.v0.8.0/Redis my-redis-service
Successfully added service to the configuration; do 'odo push' to create service on the cluster

This command creates a Kubernetes manifest in the kubernetes/ directory, containing the definition of the service, and this file is referenced from the devfile.yaml file.

$ cat kubernetes/odo-service-my-redis-service.yaml

 apiVersion: redis.redis.opstreelabs.in/v1beta1
 kind: Redis
 metadata:
   name: my-redis-service
 spec:
   kubernetesConfig:
     image: quay.io/opstree/redis:v6.2.5
     imagePullPolicy: IfNotPresent
     resources:
       limits:
         cpu: 101m
         memory: 128Mi
       requests:
         cpu: 101m
         memory: 128Mi
     serviceType: ClusterIP
   redisExporter:
     enabled: false
     image: quay.io/opstree/redis-exporter:1.0
   storage:
     volumeClaimTemplate:
       spec:
         accessModes:
         - ReadWriteOnce
         resources:
           requests:
             storage: 1Gi

$ cat devfile.yaml

[...]
components:
- kubernetes:
    uri: kubernetes/odo-service-my-redis-service.yaml
  name: my-redis-service
[...]

Note that the name of the created instance is optional. If you do not provide a name, it will be the lowercase name of the service. For example, the following command creates an instance of a Redis service named redis:

$ odo service create redis-operator.v0.8.0/Redis

$ odo service create redis-operator.v0.8.0/Redis my-redis-service --inlined
Successfully added service to the configuration; do 'odo push' to create service on the cluster

$ cat devfile.yaml

[...]
components:
- kubernetes:
    inlined: |
      apiVersion: redis.redis.opstreelabs.in/v1beta1
      kind: Redis
      metadata:
        name: my-redis-service
      spec:
        kubernetesConfig:
          image: quay.io/opstree/redis:v6.2.5
          imagePullPolicy: IfNotPresent
          resources:
            limits:
              cpu: 101m
              memory: 128Mi
            requests:
              cpu: 101m
              memory: 128Mi
          serviceType: ClusterIP
        redisExporter:
          enabled: false
          image: quay.io/opstree/redis-exporter:1.0
        storage:
          volumeClaimTemplate:
            spec:
              accessModes:
              - ReadWriteOnce
              resources:
                requests:
                  storage: 1Gi
  name: my-redis-service
[...]

$ odo service create redis-operator.v0.8.0/Redis my-redis-service \
    -p kubernetesConfig.image=quay.io/opstree/redis:v6.2.5 \
    -p kubernetesConfig.serviceType=ClusterIP \
    -p redisExporter.image=quay.io/opstree/redis-exporter:1.0
Successfully added service to the configuration; do 'odo push' to create service on the cluster

$ cat kubernetes/odo-service-my-redis-service.yaml

apiVersion: redis.redis.opstreelabs.in/v1beta1
kind: Redis
metadata:
  name: my-redis-service
spec:
  kubernetesConfig:
    image: quay.io/opstree/redis:v6.2.5
    serviceType: ClusterIP
  redisExporter:
    image: quay.io/opstree/redis-exporter:1.0

To delete a service, run the command:

$ odo service delete

$ odo service list
NAME                       MANAGED BY ODO     STATE               AGE
Redis/my-redis-service     Yes (api)          Deleted locally     5m39s

$ odo service delete Redis/my-redis-service
? Are you sure you want to delete Redis/my-redis-service Yes
Service "Redis/my-redis-service" has been successfully deleted; do 'odo push' to delete service from the cluster

Use the --force (or -f) flag to force the deletion of the service without confirmation.

To list the services created for your component, run the command:

$ odo service list

$ odo service list
NAME                       MANAGED BY ODO     STATE             AGE
Redis/my-redis-service-1   Yes (api)          Not pushed
Redis/my-redis-service-2   Yes (api)          Pushed            52s
Redis/my-redis-service-3   Yes (api)          Deleted locally   1m22s

For each service, STATE indicates if the service has been pushed to the cluster using the odo push command, or if the service is still running on the cluster but removed from the devfile locally using the odo service delete command.

To get details of a service such as its kind, version, name, and list of configured parameters, run the command:

$ odo service describe

$ odo service describe Redis/my-redis-service
Version: redis.redis.opstreelabs.in/v1beta1
Kind: Redis
Name: my-redis-service
Parameters:
NAME                           VALUE
kubernetesConfig.image         quay.io/opstree/redis:v6.2.5
kubernetesConfig.serviceType   ClusterIP
redisExporter.image            quay.io/opstree/redis-exporter:1.0

To add a storage volume to the cluster, run the command:

$ odo storage create

$ odo storage create store --path /data --size 1Gi
✓  Added storage store to nodejs-project-ufyy

$ odo storage create tempdir --path /tmp --size 2Gi --ephemeral
✓  Added storage tempdir to nodejs-project-ufyy

Please use `odo push` command to make the storage accessible to the component

In the above example, the first storage volume has been mounted to the /data path and has a size of 1Gi, and the second volume has been mounted to /tmp and is ephemeral.

To check the storage volumes currently used by the component, run the command:

$ odo storage list

$ odo storage list
The component 'nodejs-project-ufyy' has the following storage attached:
NAME      SIZE     PATH      STATE
store     1Gi      /data     Not Pushed
tempdir   2Gi      /tmp      Not Pushed

To delete a storage volume, run the command:

$ odo storage delete

$ odo storage delete store -f
Deleted storage store from nodejs-project-ufyy

Please use `odo push` command to delete the storage from the cluster

In the above example, using the -f flag force deletes the storage without asking user permission.

If your devfile has multiple containers, you can specify which container you want the storage to attach to, using the --container flag in the odo storage create command.

The following example is an excerpt from a devfile with multiple containers :

components:
  - name: nodejs1
    container:
      image: registry.access.redhat.com/ubi8/nodejs-12:1-36
      memoryLimit: 1024Mi
      endpoints:
        - name: "3000-tcp"
          targetPort: 3000
      mountSources: true
  - name: nodejs2
    container:
      image: registry.access.redhat.com/ubi8/nodejs-12:1-36
      memoryLimit: 1024Mi

In the example, there are two containers,nodejs1 and nodejs2. To attach storage to the nodejs2 container, use the following command:

$ odo storage create --container

$ odo storage create store --path /data --size 1Gi --container nodejs2
✓  Added storage store to nodejs-testing-xnfg

Please use `odo push` command to make the storage accessible to the component

You can list the storage resources, using the odo storage list command:

$ odo storage list

The component 'nodejs-testing-xnfg' has the following storage attached:
NAME      SIZE     PATH      CONTAINER     STATE
store     1Gi      /data     nodejs2       Not Pushed

Helm provides the ability to:

Parent command for tkn CLI.

$ tkn

Print shell completion code which must be evaluated to provide interactive completion. Supported shells are bash and zsh.

$ tkn completion bash

Print version information of the tkn CLI.

$ tkn version

Manage Pipelines.

$ tkn pipeline --help

Delete a Pipeline.

$ tkn pipeline delete mypipeline -n myspace

Describe a Pipeline.

$ tkn pipeline describe mypipeline

List Pipelines.

$ tkn pipeline list

Display Pipeline logs for a specific Pipeline.

$ tkn pipeline logs -f mypipeline

Start a Pipeline.

$ tkn pipeline start mypipeline

Manage PipelineRuns.

$ tkn pipelinerun -h

Cancel a PipelineRun.

$ tkn pipelinerun cancel mypipelinerun -n myspace

Delete a PipelineRun.

$ tkn pipelinerun delete mypipelinerun1 mypipelinerun2 -n myspace

Describe a PipelineRun.

$ tkn pipelinerun describe mypipelinerun -n myspace

List PipelineRuns.

$ tkn pipelinerun list -n myspace

Display the logs of a PipelineRun.

$ tkn pipelinerun logs mypipelinerun -a -n myspace

Manage Tasks.

$ tkn task -h

Delete a Task.

$ tkn task delete mytask1 mytask2 -n myspace

Describe a Task.

$ tkn task describe mytask -n myspace

List Tasks.

$ tkn task list -n myspace

Display Task logs.

$ tkn task logs mytask mytaskrun -n myspace

Start a Task.

$ tkn task start mytask -s <ServiceAccountName> -n myspace

Manage TaskRuns.

$ tkn taskrun -h

Cancel a TaskRun.

$ tkn taskrun cancel mytaskrun -n myspace

Delete a TaskRun.

$ tkn taskrun delete mytaskrun1 mytaskrun2 -n myspace

Describe a TaskRun.

$ tkn taskrun describe mytaskrun -n myspace

List TaskRuns.

$ tkn taskrun list -n myspace

Display TaskRun logs.

$ tkn taskrun logs -f mytaskrun -n myspace

Manage Conditions.

$ tkn condition --help

Delete a Condition.

$ tkn condition delete mycondition1 -n myspace

Describe a Condition.

$ tkn condition describe mycondition1 -n myspace

List Conditions.

$ tkn condition list -n myspace

Manage Pipeline Resources.

$ tkn resource -h

Create a Pipeline Resource.

$ tkn resource create -n myspace

This is an interactive command that asks for input on the name of the Resource, type of the Resource, and the values based on the type of the Resource.

Delete a Pipeline Resource.

$ tkn resource delete myresource -n myspace

Describe a Pipeline Resource.

$ tkn resource describe myresource -n myspace

List Pipeline Resources.

$ tkn resource list -n myspace

Manage ClusterTasks.

$ tkn clustertask --help

Delete a ClusterTask resource in a cluster.

$ tkn clustertask delete mytask1 mytask2

Describe a ClusterTask.

$ tkn clustertask describe mytask1

List ClusterTasks.

$ tkn clustertask list

Start ClusterTasks.

$ tkn clustertask start mytask

Manage EventListeners.

$ tkn eventlistener -h

Delete an EventListener.

$ tkn eventlistener delete mylistener1 mylistener2 -n myspace

Describe an EventListener.

$ tkn eventlistener describe mylistener -n myspace

List EventListeners.

$ tkn eventlistener list -n myspace

Display logs of an EventListener.

$ tkn eventlistener logs mylistener -n myspace

Manage TriggerBindings.

$ tkn triggerbinding -h

Delete a TriggerBinding.

$ tkn triggerbinding delete mybinding1 mybinding2 -n myspace

Describe a TriggerBinding.

$ tkn triggerbinding describe mybinding -n myspace

List TriggerBindings.

$ tkn triggerbinding list -n myspace

Manage TriggerTemplates.

$ tkn triggertemplate -h

Delete a TriggerTemplate.

$ tkn triggertemplate delete mytemplate1 mytemplate2 -n `myspace`

Describe a TriggerTemplate.

$ tkn triggertemplate describe mytemplate -n `myspace`

List TriggerTemplates.

$ tkn triggertemplate list -n myspace

Manage ClusterTriggerBindings.

$ tkn clustertriggerbinding -h

Delete a ClusterTriggerBinding.

$ tkn clustertriggerbinding delete myclusterbinding1 myclusterbinding2

Describe a ClusterTriggerBinding.

$ tkn clustertriggerbinding describe myclusterbinding

List ClusterTriggerBindings.

$ tkn clustertriggerbinding list

Interact with hub.

$ tkn hub -h

$ tkn hub --api-server https://api.hub.tekton.dev

Downgrade an installed resource.

$ tkn hub downgrade task mytask --to version -n mynamespace

Get a resource manifest by its name, kind, catalog, and version.

$ tkn hub get [pipeline | task] myresource --from tekton --version version

Display information about a resource by its name, kind, catalog, and version.

$ tkn hub info task mytask --from tekton --version version

Install a resource from a catalog by its kind, name, and version.

$ tkn hub install task mytask --from tekton --version version -n mynamespace

Reinstall a resource by its kind and name.

$ tkn hub reinstall task mytask --from tekton --version version -n mynamespace

Search a resource by a combination of name, kind, and tags.

$ tkn hub search --tags cli

Upgrade an installed resource.

$ tkn hub upgrade task mytask --to version -n mynamespace

The bundle validate subcommand validates an Operator bundle.

The create api subcommand scaffolds a Kubernetes API. The subcommand must be run in a project that was initialized with the init command.

The generate bundle subcommand generates a set of bundle manifests, metadata, and a bundle.Dockerfile file for your Operator project.

The generate kustomize subcommand contains subcommands that generate Kustomize data for the Operator.

The run bundle subcommand deploys an Operator in the bundle format with Operator Lifecycle Manager (OLM).

The run bundle-upgrade subcommand upgrades an Operator that was previously installed in the bundle format with Operator Lifecycle Manager (OLM).