Merge pull request #536 from adity1raut/main

📖 docs: remove OCM-type control plane usage examples

Author: pdettori

docs/contributors.md

@@ -91,78 +91,3 @@ LATEST_TAG=<tag used for image> make ko-build-push-cmupdate
 
 1. To avoid leaving a time bomb, delete that `brew` branch after it was merged into `main` (the goreleaser will fail to create the new `brew` branch if one already exists).
 
-
-## OCM Images
-
-### Commands to build & publish multicluster-controlplane from fork
-
-At this time the official multicluster-controlplane has issues and a build from
-a fork is required. We expect to re-evaluate when new images will be published
-by the OCM community.
-
-1. Build and publish image from fork
-
-```shell
-git clone https://github.com/pdettori/multicluster-controlplane.git
-cd multicluster-controlplane
-git checkout kubeflex
-make image
-docker tag quay.io/open-cluster-management/multicluster-controlplane:latest quay.io/kubestellar/multicluster-controlplane:v0.2.0-kf-alpha.1
-docker push quay.io/kubestellar/multicluster-controlplane:v0.2.0-kf-alpha.1
-```
-### Commands to package and push a chart to a OCI registry
-
-First clone and build image as explained in [Commands to build & publish multicluster-controlplane from fork](#commands-to-build--publish-multicluster-controlplane-from-fork), then:
-
-```shell
-helm package charts/multicluster-controlplane --version v0.2.0-kf-alpha.1
-helm push *.tgz oci://quay.io/kubestellar
-```
-
-### Hosting a copy of postgresql chart and image on quay.io
-
-1. Select the desired postgresql chart tag:
-
-   For example `CHART_TAG=13.1.5`.
-
-2. Pull the chart from the bitmani Docker registry:
-
-   ```shell
-   helm pull oci://registry-1.docker.io/bitnamicharts/postgresql:$CHART_TAG
-   ```
-
-3. Unpack the downloaded `postgresql-$CHART_TAG.tgz` archive:
-
-   ```shell
-   tar xf postgresql-$CHART_TAG.tgz
-   ```
-
-4. In the newly created `postgresql` folder open the `values.yaml` and find the `image:` section:
-
-   - Change the `registry:` from `docker.io` to `quay.io`.
-   - Change the `repository:` from `bitnami/postgresql` to `kubestellar/postgresql`.
-   - Take note of the image tag, for example `IMAGE_TAG=16.0.0-debian-11-r13`.
-
-5. Repackage the chart in a tarball with the same name:
-
-   ```shell
-   tar czf postgresql-$CHART_TAG.tgz postgresql/
-   ```
-
-6. Push the customized chart to quay.io:
-
-   ```shell
-   helm login quay.io
-   helm push postgresql-$CHART_TAG.tgz oci://quay.io/kubestellar/charts
-   ```
-
-7. Update the postgresql Helm chart reference that is hard coded in [postgresql.yaml](../chart/templates/postgresql.yaml#L97) to match the quay.io registry, repository, and tag used in the Helm push command of step 6.
-
-8. Make a multi-arch copy of postgresql container image from `docker.io` to `quay.io` to match the customized chart image reference:
-
-   ```shell
-   docker login quay.io
-   docker buildx imagetools create --tag quay.io/kubestellar/postgresql:$IMAGE_TAG docker.io/bitnami/postgresql:$IMAGE_TAG
-   ```
-
-   The registry, repository, and tag used in this command must match the values included in the customized chart at step 4.

docs/users.md

@@ -464,154 +464,6 @@ NAME               TYPE     DATA   AGE
 admin-kubeconfig   Opaque   1      4m47s
 ```
 
-## Working with an OCM control plane
-
-Let's create an OCM control plane:
-
-```console
-$ kflex create cp3 --type ocm
-✔ Checking for saved hosting cluster context...
-✔ Switching to hosting cluster context...
-✔ Creating new control plane cp3...
-✔ Waiting for API server to become ready...
-```
-
-We may check the CRDs available for the OCM control plane:
-
-```console
-$ kubectl get crds
-NAME                                                           CREATED AT
-addondeploymentconfigs.addon.open-cluster-management.io        2023-07-08T21:17:44Z
-addonplacementscores.cluster.open-cluster-management.io        2023-07-08T21:17:44Z
-clustermanagementaddons.addon.open-cluster-management.io       2023-07-08T21:17:44Z
-managedclusteraddons.addon.open-cluster-management.io          2023-07-08T21:17:44Z
-managedclusters.cluster.open-cluster-management.io             2023-07-08T21:17:44Z
-managedclustersetbindings.cluster.open-cluster-management.io   2023-07-08T21:17:44Z
-managedclustersets.cluster.open-cluster-management.io          2023-07-08T21:17:44Z
-manifestworks.work.open-cluster-management.io                  2023-07-08T21:17:44Z
-placementdecisions.cluster.open-cluster-management.io          2023-07-08T21:17:44Z
-placements.cluster.open-cluster-management.io                  2023-07-08T21:17:44Z
-```
-
-We may also register clusters with the OCM control plane and deploy workloads
-using the `ManifestWork` API. In order to do that, you need first to install
-the Open Cluster Management [clusteradm CLI](https://open-cluster-management.io/getting-started/installation/start-the-control-plane/), e.g.
-
-```shell
-curl -L https://raw.githubusercontent.com/open-cluster-management-io/clusteradm/main/install.sh | bash
-```
-
-With the current context set to the ocm control plane, we can use `clusteradm` to retrieve a token
-used to register managed clusters:
-
-```shell
-clusteradm get token --use-bootstrap-token
-clusteradm join --hub-token <some value> --hub-apiserver https://cp3.localtest.me:9443/ --cluster-name <cluster_name>
-```
-
-The command returns the command to run on the managed cluster (actual token value not shown in example).
-
-Now create a kind cluster to register with ocm, with the command:
-
-```shell
-kind create cluster --name cluster1
-```
-
-Once the cluster is ready, run the command above, taking care of replacing <cluster_name> with cluster1
-and leaving the actual token value. Most importantly, make sure to add the flag `--force-internal-endpoint-lookup` which allows the managed cluster to communicate with the OCM control plane
-using the docker network that all kind clusters share. Note that the `kind create cluster` command
-switches the context to the new cluster `cluster`, so the `clusteramd join` command is run using the
-new cluster context.
-
-```shell
-clusteradm join --hub-token <some value> --hub-apiserver https://cp3.localtest.me:9443/ --cluster-name cluster1 --force-internal-endpoint-lookup
-```
-
-At this point, switch back the context to the OCM control plane with the command:
-
-```shell
-kflex ctx cp3
-```
-
-and verifies that a Certificate Signing Request (csr) has been created on the OCM control plane
-running the command `kubectl get csr`. The CSR request is part of the mechanism used by OCM
-to register a new cluster. You should see an output simlar to the following:
-
-```console
-$ kubectl get csr
-NAME             AGE   SIGNERNAME                            REQUESTOR                 REQUESTEDDURATION   CONDITION
-cluster1-zx5x5   7s    kubernetes.io/kube-apiserver-client   system:bootstrap:j5bork   <none>              Pending
-```
-
-Approve the csr to complete the cluster registration with the command:
-
-```shell
-clusteradm accept --clusters cluster1
-```
-
-You can now see the new cluster in the OCM inventory:
-
-```console
-$ kubectl get managedclusters
-NAME       HUB ACCEPTED   MANAGED CLUSTER URLS                  JOINED   AVAILABLE   AGE
-cluster1   true           https://cluster1-control-plane:6443   True     True        3m25s
-```
-
-Finally, you may deploy a workload on the managed cluster using the ManifestWork API:
-
-```shell
-kubectl apply -f - <<EOF
-apiVersion: work.open-cluster-management.io/v1
-kind: ManifestWork
-metadata:
-  namespace: cluster1
-  name: deployment1
-spec:
-  workload:
-    manifests:
-      - apiVersion: v1
-        kind: ServiceAccount
-        metadata:
-          namespace: default
-          name: my-sa
-      - apiVersion: apps/v1
-        kind: Deployment
-        metadata:
-          namespace: default
-          name: nginx-deployment
-          labels:
-            app: nginx
-        spec:
-          replicas: 3
-          selector:
-            matchLabels:
-              app: nginx
-          template:
-            metadata:
-              labels:
-                app: nginx
-            spec:
-              serviceAccountName: my-sa
-              containers:
-                - name: nginx
-                  image: nginx:1.14.2
-                  ports:
-                    - containerPort: 80
-EOF
-```
-To check the workload has been deployed, switch context back to the managed cluster
-and list deployments:
-
-```shell
-kflex ctx kind-cluster1
-```
-
-```console
-$ kubectl get deployments.apps
-NAME               READY   UP-TO-DATE   AVAILABLE   AGE
-nginx-deployment   3/3     3            3           20s
-```
-
 ## Working with a vcluster control plane
 
 Let's create a vcluster control plane: