Alternate Ways to Create an OpenShift Project
Tags: kubernetes, openshift, ibmcloud, jenkins
Published: 2020-04-14 02:48:19

---
title: Alternate Ways to Create an OpenShift Project
published: true
date: 2019-10-25 12:00:00 UTC
tags: kubernetes,openshift,ibm-cloud,jenkins
canonical_url: 
---

![](https://cdn-images-1.medium.com/max/1024/0*mKwRSHcM5cjBz8gm)

### This post explains two of the ways to create an OpenShift project-inside the Jenkinsfile and using a template.

While working on a demo, I came across a use case where I need to create an OpenShift project via a Jenkinsfile. So, I started exploring various ways to create a project. This post explains two of the ways-one inside the Jenkinsfile and other using a template.

If you are new to the [OpenShift world](https://www.ibm.com/cloud/blog/new-builders/what-is-openshift), a project is a [Kubernetes](https://www.ibm.com/cloud/learn/kubernetes) namespace with additional annotations.

The easiest way to create a project is by using the oc command:

### Creating an OpenShift project in a Jenkinsfile

Jenkinsfiles are written in Groovy Domain Specific Language (DSL) syntax. The Jenkins Pipeline execution engine supports two DSL syntaxes: Declarative and Scripted. A part of the declarative pipeline syntax looks as shown below:

```
stage('preamble') {
   steps {
     script {
       openshift.withCluster() {
         sh 'oc new-project development'
         sh 'oc new-project testing'
         sh 'oc new-project production'
         openshift.withProject() {
           echo "Using project: ${openshift.project()}"
         }
       }
     }
   }
 }
```

As you can see, the shline in the syntax above is an indication that shell commands can be executed inside the Jenkinsfile. You can also execute a shell script file.

Refer to [this link to see a sample Jenkinsfile with declarative syntax](https://docs.openshift.com/container-platform/3.11/dev_guide/dev_tutorials/openshift_pipeline.html).

Before using the above syntax, the Jenkins service account needs to have self-provisioner permission:

```
oc adm policy add-cluster-role-to-user self-provisioner -z jenkins
```

This is the simple and straightforward. The other way to create a project is using a template, which I’ll detail in the following section.

### Creating an OpenShift project using templates

A template describes a set of objects that can be parameterized and processed to produce a list of objects for creation by the OpenShift Container Platform. A template can be processed to create anything you have permission to create within a project, such as services, build configurations, and deployment configurations. A template can also define a set of labels to apply to every object defined in the template.

The [OpenShift cluster](https://cloud.ibm.com/kubernetes/landing?platformType=openshift) comes with built-in templates. To check all of them, run the following command:

```
oc get templates -n openshift
```

Let’s start by creating a bootstrap template file:

```
oc adm create-bootstrap-project-template -o yaml > template.yaml
```

The generated template.yaml should look like this:

```
apiVersion: template.openshift.io/v1
kind: Template
metadata:
  creationTimestamp: null
  name: project-request
objects:
- apiVersion: project.openshift.io/v1
  kind: Project
  metadata:
    annotations:
      openshift.io/description: ${PROJECT\_DESCRIPTION}
      openshift.io/display-name: ${PROJECT\_DISPLAYNAME}
      openshift.io/requester: ${PROJECT\_REQUESTING\_USER}
    creationTimestamp: null
    name: ${PROJECT\_NAME}
  spec: {}
  status: {}
- apiVersion: rbac.authorization.k8s.io/v1
  kind: RoleBinding
  metadata:
    annotations:
      openshift.io/description: Allows all pods in this namespace to pull images from
        this namespace. It is auto-managed by a controller; remove subjects to disable.
    creationTimestamp: null
    name: system:image-pullers
    namespace: ${PROJECT\_NAME}
  roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: system:image-puller
  subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: Group
    name: system:serviceaccounts:${PROJECT\_NAME}
- apiVersion: rbac.authorization.k8s.io/v1
  kind: RoleBinding
  metadata:
    annotations:
      openshift.io/description: Allows builds in this namespace to push images to
        this namespace. It is auto-managed by a controller; remove subjects to disable.
    creationTimestamp: null
    name: system:image-builders
    namespace: ${PROJECT\_NAME}
  roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: system:image-builder
  subjects:
  - kind: ServiceAccount
    name: builder
    namespace: ${PROJECT\_NAME}
- apiVersion: rbac.authorization.k8s.io/v1
  kind: RoleBinding
  metadata:
    annotations:
      openshift.io/description: Allows deploymentconfigs in this namespace to rollout
        pods in this namespace. It is auto-managed by a controller; remove subjects
        to disable.
    creationTimestamp: null
    name: system:deployers
    namespace: ${PROJECT\_NAME}
  roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: system:deployer
  subjects:
  - kind: ServiceAccount
    name: deployer
    namespace: ${PROJECT\_NAME}
- apiVersion: rbac.authorization.k8s.io/v1
  kind: RoleBinding
  metadata:
    creationTimestamp: null
    name: admin
    namespace: ${PROJECT\_NAME}
  roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: admin
  subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: ${PROJECT\_ADMIN\_USER}
parameters:
- name: PROJECT\_NAME
- name: PROJECT\_DISPLAYNAME
- name: PROJECT\_DESCRIPTION
- name: PROJECT\_ADMIN\_USER
- name: PROJECT\_REQUESTING\_USER
```

If you observe closely, there are few parameters that needs to be passed, and you can do that with the following command. This command created a project called dev:

```
oc process -f template.yaml -p PROJECT\_NAME=dev -p PROJECT\_DESCRIPTION=development -p PROJECT\_DISPLAYNAME=dev -p PROJECT\_REQUESTING\_USER=vidya | oc create -f -
```

Now, when you run the below command you should see a new project dev in the list of projects:

```
oc projects
```

### See the solution tutorial to learn more

Experience all of this by creating a [Red Hat OpenShift cluster on IBM Cloud](https://www.ibm.com/cloud/openshift) by following the step-by-step instructions mentioned in this solution tutorial: “ [Scalable web application on OpenShift](https://cloud.ibm.com/docs/tutorials?topic=solution-tutorials-scalable-webapp-openshift).”

_Originally published at_ [_https://www.ibm.com_](https://www.ibm.com/cloud/blog/alternate-ways-to-create-an-openshift-project) _on October 25, 2019._