Developer Tools CLI

igc dashboard
Copied!

HOST=$(oc get routes/dashboard -n tools -o jsonpath='{.spec.host}')
open "https://$HOST"
Copied!

HOST=$(kubectl get ingress/developer-dashboard -n tools -o jsonpath='{.spec.rules[0].host}')
open "https://$HOST"
Copied!

igc credentials
Copied!

Credentials:  {
  argocd: {
    user: 'admin',
    password: '12345678',
    url: 'https://argocd-tools.mycluster.us-east.containers.appdomain.cloud'
  },
  . . .
  dashboard: {
    url: 'https://dashboard-tools.mycluster.us-east.containers.appdomain.cloud'
Copied!

# config maps
kubectl get configmap -n tools -l grouping=garage-cloud-native-toolkit -o json | \
  jq '[.items[] | select(.metadata.name != "ibmcloud-config").data]'
# secrets
kubectl get secret -n tools -l grouping=garage-cloud-native-toolkit -o json | \
  jq '[.items[] | select(.metadata.name != "ibmcloud-apikey").data | with_entries(.value |= @base64d)]'
Copied!

igc endpoints
Copied!

# routes
kubectl get route -n tools
# ingress
kubectl get ingress -n tools
Copied!

kubectl get ingress -n tools
Copied!

igc sync test
Copied!

igc sync dev --dev
Copied!

export NAMESPACE="NAMESPACE"
export SERVICE_ACCOUNT="default"
if [[ $(kubectl get secrets -n "${NAMESPACE}" -o jsonpath='{ range .items[*] }{ .metadata.name }{ "\n" }{ end }' | grep icr | wc -l | xargs) -eq 0 ]]; then
    echo "*** Copying pull secrets from default namespace to ${NAMESPACE} namespace"
    kubectl get secrets -n default | grep icr | sed "s/\([A-Za-z-]*\) *.*/\1/g" | while read default_secret; do
        kubectl get secret ${default_secret} -n default -o yaml --export | sed "s/name: default-/name: /g" | kubectl -n ${NAMESPACE} create -f -
    done
Copied!

  export TEMPLATE_NAMESPACE="tools"
  export NAMESPACE="NAMESPACE"
  kubectl get configmap -l grouping=garage-cloud-native-toolkit -n ${TEMPLATE_NAMESPACE} -o jsonpath='{ range .items[*] }{ .metadata.name }{ "\n" }{ end }' | \
    while read cm; do
      kubectl get configmap ${cm} --namespace ${TEMPLATE_NAMESPACE} --export -o yaml | \
        kubectl apply --namespace $NAMESPACE -f -
    done
Copied!

igc pipeline --jenkins
Copied!

igc pipeline -n my-dev -u gituser -p gitpat --tekton
Copied!

• Configure the service account pipeline if it doesn’t exist, on OpenShift 4 the operator takes care of this you can skip.

  oc create serviceaccount pipeline
  oc adm policy add-scc-to-user privileged -z pipeline
  oc adm policy add-role-to-user edit -z pipeline
  Copied!

• Clone the tasks from the tools namespace into the new-namespace

  kubectl get tasks --export -o yaml -n tools  | sed s/"namespace: tools/namespace: $(oc project -q)"/ | kubectl apply -f -
  Copied!

• Clone the pipelines from the tools namespace into the new-namespace

  kubectl get pipelines --export -o yaml -n tools  | sed s/"namespace: tools/namespace: $(oc project -q)"/ | kubectl apply -f -
  Copied!

Pipeline Resource

• Create a Pipeline resource for the git repository, replace with the correct github url for your repository Use the tkn CLI to create git resource input the github repo url for url and branch for revision

  tkn resource create
  Copied!

  Here is the an example of the cli

  tkn resource create
  ? Enter a name for a pipeline resource : nodejs-typescript-git
  ? Select a resource type to create : git
  ? Enter a value for url :  https://github.com/{user or org}/{app}
  ? Enter a value for revision :  master
  New git resource "nodejs-typescript-git" has been created
  Copied!

• Create a Pipeline resource for the docker image registry, you can use the internal registry in OpenShift or use an external registry like IBM Container Registry (credentials need setup) Use the tkn CLI to create image resource

  tkn resource create
  Copied!

  Select image for type.

  Enter the corresponding url for container registry, use the new-namespace} in the url

  For OCP 3 internal registry use docker-registry.default.svc:5000/{new-namespace}/node-typescript:latest

  For OCP 4 or CRC internal registry use image-registry.openshift-image-registry.svc:5000/{new-namespace}/node-typescript:latest

  For external registry like IBM Container registry based on region use us.icr.io/{namespace}/node-typescript:latest use an existing namespace in your IBM Cloud

  tkn resource create
  ? Enter a name for a pipeline resource : nodejs-typescript-image
  ? Select a resource type to create : image
  ? Enter a value for url :  docker-registry.default.svc:5000/dev/node-typescript:latest
  ? Enter a value for digest :
  New image resource "nodejs-typescript-image" has been created
  Copied!

• Select the pipeline, to show the available pipeline run

  tkn pipeline ls
  NAME              AGE              LAST RUN   STARTED   DURATION   STATUS
  igc-java-gradle   33 minutes ago   ---        ---       ---        ---
  igc-nodejs        33 minutes ago   ---        ---       ---        ---
  Copied!

  In this case use igc-java-gradle for java or igc-nodejs for nodejs.

• Run the Pipeline using the git and image Pipeline resources. Set the following environment variable for convienience:

  export PIPELINE=igc-nodejs
  export GIT=nodejs-typescript-git
  export IMAGE=nodejs-typescript-image
  Copied!

  Then run the tkn pipeline start with the input arguments using the service account pipeline

  tkn pipeline start \
  ${PIPELINE} \
  -r git-source=${GIT} \
  -r docker-image=${IMAGE} \
  -s pipeline
  Copied!

Create a Git Webhook

• Open the Tekton Dashboard from the main Tools Dashboard or the ICPA landing page.

• Create a Webhook in the Tekton Dashboard

- Click **Webhook** on the menu
- Click **Add Webhook** and enter the information for the webhook
- Name: **insert name**
- Repository UR: **template git repo url**
- Access Token: Create github access token with permission minimum write:repo_hook
- Namespace: **insert namespace**
- Pipeline: select **igc-java-gradle** or **igc-nodejs**
- Service Account: **pipeline**
- Docker Registry:
Copied!

• Check that Webhook is created on the Github repository (Settings-Webhooks)

• Make a change to the git repo and push the change to remote git repository or click on Pipelines and manually kick of a pipeline build

1. Provision Jenkins ephemeral

1. Set the project/namespace

oc project {NAMESPACE}
Copied!

• {NAMESPACE} is the development namespace where the pipelines will run

2. Run the following command to provision the Jenkins instance in your namespace

oc new-app jenkins-ephemeral
Copied!

3. Open the OpenShift console as described in the login steps above

4. Select Workloads -> Pods from the left-hand menu

5. At the top of the page select your project/namespace from the drop-down list to see the Jenkins instance running

2. Give the jenkins service account privileged access

oc project {NAMESPACE}
oc adm policy add-scc-to-user privileged -z jenkins
Copied!

• {NAMESPACE} should be the name you claimed in the box note prefixed to -dev (e.g. user01-dev)

3. Create a secret with git credentials

1. Create a personal access token (if you don’t already have one) using the prereq instructions - https://cloudnativetoolkit.dev/getting-started/prereqs#configure-github-personal-access-token

2. Copy the following into a file called gitsecret.yaml and update the {Git-Username}, and {Git-PAT}

apiVersion: v1
kind: Secret
metadata:
  annotations:
    build.openshift.io/source-secret-match-uri-1: https://github.com/*
  labels:
    jenkins.io/credentials-type: usernamePassword
  name: git-credentials
type: kubernetes.io/basic-auth
Copied!

• Git-Username is the username that has access to the git repo
• Git-PAT is the personal access token of the git user

2. After logging into the cluster, create the secret by running the following:

oc project {NAMESPACE}
oc create -f gitsecret.yaml
Copied!

• {NAMESPACE} is the development namespace where the pipelines will run

3. Create the build config

1. Copy the following into a file called buildconfig.yaml and update the {Name}, {Secret}, {Git-Repo-URL}, and {Namespace}

apiVersion: v1
kind: BuildConfig
metadata:
  name: {Name}
spec:
  triggers:
  - type: GitHub
    github:
      secret: my-secret-value
Copied!

• Name is in the name of your pipeline
• Git-Repo-URL is the https url to the git repository
• {NAMESPACE} is the development namespace where the pipelines will run

2. Assuming you are still logged into the cluster, create the buildconfig resource in the cluster

oc project {NAMESPACE}
oc create -f buildconfig.yaml
Copied!

• {NAMESPACE} is the development namespace where the pipelines will run

4. View the pipeline in the OpenShift console

1. Open the OpenShift console for the cluster
2. Select Builds -> Build Config
3. Select your project/namespace (i.e. {NAMESPACE}) from the top
4. The build pipeline that was created in the previous step should appear
5. Manually trigger the pipeline by selecting Start Build the menu button on the right side of the row

5. Create the webhook

1. Run the following to get the webhook details from the build config

oc project {NAMESPACE}
oc describe bc {Name}
Copied!

• {Name} is the name used in the previous step for the build config
• {NAMESPACE} is the development namespace where the pipelines will run

2. Open a browser to the GitHub repo deployed in the previous step in the build config

3. Select Settings then Webhooks. Press Add webhook

4. Paste the webhook url from the previous step into the Payload url

5. Set the content-type to application/json and leave the rest of the values as the defaults

6. Press Add webhook to create the webhook

7. Press the button to test the webhook to ensure that everything was done properly

8. Go back to your project code and push a change to one of the files

9. Go to the Build pipeline page in the OpenShift console to see that the build was triggered

1. Before running the command, make sure you have a clean repository with no unstaged changes. Either commit any changes or stash them temporarily with git stash. It is particularly important that any changes to the pipeline be dealt with.

2. Apply the pipeline updates using the CLI command

igc enable
Copied!

3. Review the changes using git diff and revert any application-specific changes that should remain (e.g. customization to the Jenkins pipeline in the Jenkinsfile, specific values added to values.yaml, customizations to the templates in the helm chart)

4. Commit the changes when you are happy with them

1. Before updating the pipelines, make sure you have a clean repository with no unstaged changes. Either commit any changes or stash them temporarily with git stash. It is particularly important that any changes to the pipeline be dealt with.

2. Download the index.yaml file containing the available pipeline versions

   curl -O https://ibm-garage-cloud.github.io/garage-pipelines/index.yaml
   Copied!

3. Look through the index.yaml file to identify the url for the desired pipeline branch and version

4. With the PIPELINE_URL from the previous step, run the following to download the pipeline tar-ball

   curl -O ${PIPELINE_URL}
   Copied!

5. Extract the tar-ball into your repository directory. You will be prompted to overwrite files. Overwrite as appropriate

   ```shell script
   tar xzf ${PIPELINE_FILE}
   ```
   Copied!

6. Review the changes using git diff and revert any application-specific changes that should remain (e.g. customization to the Jenkins pipeline in the Jenkinsfile, specific values added to values.yaml, customizations to the templates in the helm chart)

7. Commit the changes when you are happy with them