Cloud Native Toolkit CLI

igc dashboard
Copy to clipboardCopied!

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

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

igc console
Copy to clipboardCopied!

open $(oc whoami --show-console)
Copy to clipboardCopied!

REGION="..."
CLUSTER_NAME="..."
CLUSTER_ID=$(ibmcloud ks cluster get --cluster ${CLUSTER_NAME} | grep -E "^ID" | sed -E "s/ID: +([^ ]+)/\\1/g")
open "https://${REGION}.containers.cloud.ibm.com/kubeproxy/clusters/${CLUSTER_ID}/service/#/overview?namespace=default"
Copy to clipboardCopied!

igc git
Copy to clipboardCopied!

igc git origin-fork
Copy to clipboardCopied!

alias gh="open https://github.$(git config remote.origin.url | cut -f2 -d. | tr ':' /)"
Copy to clipboardCopied!

igc credentials
Copy to clipboardCopied!

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'
Copy to clipboardCopied!

# 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)]'
Copy to clipboardCopied!

igc endpoints
Copy to clipboardCopied!

# routes
kubectl get route -n tools
# ingress
kubectl get ingress -n tools
Copy to clipboardCopied!

kubectl get ingress -n tools
Copy to clipboardCopied!

igc sync myapp-dev
Copy to clipboardCopied!

oc sync myapp-dev
Copy to clipboardCopied!

kubectl sync myapp-dev
Copy to clipboardCopied!

  export TEMPLATE_NAMESPACE="tools"
  export NAMESPACE="NAMESPACE"
  kubectl get configmap -l group=catalyst-tools -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
Copy to clipboardCopied!

igc pull-secret myapp-test -t default -z default
Copy to clipboardCopied!

export NAMESPACE="myapp-test"
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
Copy to clipboardCopied!

oc pipeline --jenkins
Copy to clipboardCopied!

oc pipeline -n my-dev -u gituser -P gitpat --tekton
Copy to clipboardCopied!

1. Set the current namespace/project

   For OpenShift:

   oc project {namespace}
   Copy to clipboardCopied!

   For Kubernetes:

   kubectl config set-context --current --namespace={namespace}
   Copy to clipboardCopied!

2. Copy the tasks from the tools namespace into the current namespace

   kubectl get tasks -o json -n tools | \
     jq 'del(.items[].metadata.uid) | del(.items[].metadata.selfLink) | del(.items[].metadata.resourceVersion) | del(.items[].metadata.namespace) | del(.items[].metadata.creationTimestamp) | del(.items[].metadata.generation) | del(.items[].metadata.annotations."kubectl.kubernetes.io/last-applied-configuration")' | \
     kubectl apply -f -
   Copy to clipboardCopied!

3. List the available pipeline templates in the tools namespace and select the one to use for your project.

   kubectl get pipelines -n tools
   Copy to clipboardCopied!

4. Clone the selected pipeline from the tools namespace into the current namespace

   kubectl get pipeline ${TEMPLATE_NAME} -o json -n tools | \
     jq --arg PIPELINE_NAME ${PIPELINE_NAME} '.metadata.name = $PIPELINE_NAME | del(.metadata.uid) | del(.metadata.selfLink) | del(.metadata.resourceVersion) | del(.metadata.namespace) | del(.metadata.creationTimestamp) | del(.metadata.generation) | del(.metadata.annotations."kubectl.kubernetes.io/last-applied-configuration")' | \
     kubectl apply -f -
   Copy to clipboardCopied!

   where:

   • TEMPLATE_NAME is the name of the pipeline selected in the previous step
   • PIPELINE_NAME is the name of the pipeline for your project

Start the pipeline

• Kick off the pipeline using the Tekton CLI

  tkn pipeline start {PIPELINE_NAME} -s pipeline -p git-url={GIT_REPO} -p git-revision={GIT_BRANCH}
  Copy to clipboardCopied!

• To create a new PipelineRun with the same parameters from a previous PipelineRun you can do the following

  tkn pipeline start {PIPELINE_NAME} --use-pipelinerun {PIPELINE_RUN_NAME}
  Copy to clipboardCopied!

Create a Git Webhook

Create the event listener and triggers

• TriggerTemplate - defines how to create the PipelineRun and any other required resources when a webhook notification is received.
• TriggerBinding - provides a mapping for the information available in the webhook payload into the TriggerTemplate
• EventListener - makes the connection between the Pipeline, TriggerBinding, and TriggerTemplate together that will be created when a webhook is triggered

1. Create a file named tekton-trigger.yaml and paste in the following contents:

   apiVersion: triggers.tekton.dev/v1alpha1
   kind: TriggerTemplate
   metadata:
     labels:
       app: {PIPELINE_NAME}
     name: {TRIGGER_TEMPLATE_NAME}
   spec:
     params:
     - description: The git revision
   Copy to clipboardCopied!

2. Replace the place holder values with the appropriate values:

   where:

   • {PIPELINE_NAME} is the name of your Pipeline resource from the previous section.
   • {TRIGGER_TEMPLATE_NAME} is the name of the TriggerTemplate. This can be the same as the {PIPELINE_NAME}.
   • {TRIGGER_BINDING_NAME} is the name of the TriggerBinding. This can be the same as the {PIPELINE_NAME}.
   • {EVENT_LISTENER_NAME} is the name of the EventListener. This can be el-{PIPELINE_NAME} if the EventListeners will be configured one-to-one with the Pipelines or the instance can be shared across the project.
   • {BRANCH_NAME} is the name of the branch from which webhook events should trigger the build to start

3. Apply the trigger resources to the cluster, in the same namespace where the Pipeline was created

   kubectl apply -f tekton-trigger.yaml
   Copy to clipboardCopied!

4. In order for the Git repository to trigger the build with a webhook, an endpoint needs to be available. Expose the EventListener service with a route to provide that endpoint.

   oc expose service ${EVENT_LISTENER_NAME} --name=${EVENT_LISTENER_NAME}
   Copy to clipboardCopied!

Register the webhook url with your Git repository

1. Get the host name for the route created in the previous step

   oc get route ${EVENT_LISTENER_NAME} -o jsonpath='{.spec.host}'
   Copy to clipboardCopied!

2. Create a webhook in your hosted Git repository using the https url of the host name from the previous step that is triggered by the desired events (e.g. push, pull request, release)

1. Provision Jenkins ephemeral

1. Set the project/namespace

   oc project {NAMESPACE}
   Copy to clipboardCopied!

   where:

   • {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
   Copy to clipboardCopied!

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
Copy to clipboardCopied!

• {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
   Copy to clipboardCopied!

   where:

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

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

   oc project {NAMESPACE}
   oc create -f gitsecret.yaml
   Copy to clipboardCopied!

   where:

   • {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}

   ```yaml
   apiVersion: v1
   kind: BuildConfig
   metadata:
     name: {Name}
   spec:
     triggers:
     - type: GitHub
       github:
   Copy to clipboardCopied!

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

   oc project {NAMESPACE}
   oc create -f buildconfig.yaml
   Copy to clipboardCopied!

   where:

   • {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}
   Copy to clipboardCopied!

   where:

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

   The webhook url will have a structure similar to:

   http://{openshift_api_host:port}/oapi/v1/namespaces/{namespace}/buildconfigs/{name}/webhooks/{secret}/generic

   In this case {secret} will be my-secret-value

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
   Copy to clipboardCopied!

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://cloud-native-toolkit.github.io/garage-pipelines/index.yaml
   Copy to clipboardCopied!

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}
   Copy to clipboardCopied!

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

   tar xzf ${PIPELINE_FILE}
   Copy to clipboardCopied!

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

igc git-secret -n dev
Copy to clipboardCopied!

1. Create the git-credentials secret

   kubectl create secret generic git-credentials -n dev \
     --from-literal=username={git username} \
     --from-literal=password={git personal access token} \
     --dry-run --output=yaml | \
   kubectl label -f - --local --dry-run --output=yaml \
     "jenkins.io/credentials-type=usernamePassword" | \
   kubectl annotate -f - --local --dry-run --output=yaml \
     "build.openshift.io/source-secret-match-uri-1=https://github.com/*" \
     "tekton.dev/git-0=https://github.com" | \
   Copy to clipboardCopied!

2. Create the config map for a git repo located at https://github.com/showcase/myrepo

   kubectl create configmap showcase.myrepo -n dev \
     --from-literal=host=github.com \
     --from-literal=org=showcase \
     --from-literal=repo=myrepo \
     --from-literal=url=https://github.com/showcase/myrepo \
     --from-literal=branch=master
   Copy to clipboardCopied!

igc gitops -n dev
Copy to clipboardCopied!

1. Create the git-credentials secret

   kubectl create secret generic git-credentials -n dev \
     --from-literal=username={git username} \
     --from-literal=password={git personal access token} \
     --dry-run --output=yaml | \
   kubectl label -f - --local --dry-run --output=yaml \
     "jenkins.io/credentials-type=usernamePassword" | \
   kubectl annotate -f - --local --dry-run --output=yaml \
     "build.openshift.io/source-secret-match-uri-1=https://github.com/*" \
     "tekton.dev/git-0=https://github.com" | \
   Copy to clipboardCopied!

2. Create the config map for a git repo located at https://github.com/showcase/myrepo

   kubectl create configmap github-repo -n dev \
     --from-literal=host=github.com \
     --from-literal=org=showcase \
     --from-literal=repo=myrepo \
     --from-literal=url=https://github.com/showcase/myrepo \
     --from-literal=branch=master
   Copy to clipboardCopied!

igc tool-config my-tool \
  --url https://mytool-dashboard.mycluster.us-east.containers.appdomain.cloud \
  --username admin \
  --password password
Copy to clipboardCopied!

helm install my-tool tool-config \
  --repo https://cloud-native-toolkit.github.io/toolkit-charts/ \
  --set url=https://mytool-dashboard.mycluster.us-east.containers.appdomain.cloud \
  --set username=admin \
  --set password=password
Copy to clipboardCopied!

igc vlan
Copy to clipboardCopied!

1. List the zones for the region

   ibmcloud ks zones --region-only --provider classic
   Copy to clipboardCopied!

2. Select the desired zone from the listing provided by the previous command and run the following to list the vlans for that zone

   ibmcloud ks vlans --zone ${zone}
   Copy to clipboardCopied!