Memigrasikan container ke Google Cloud: Memigrasikan project OpenShift ke GKE Enterprise

Last reviewed 2022-01-24 UTC

Dokumen ini membantu Anda merencanakan, mendesain, dan mengimplementasikan migrasi project dari OpenShift ke GKE Enterprise. Jika Anda salah melakukannya, memindahkan beban kerja dari satu lingkungan ke lingkungan lain dapat menjadi tugas yang menantang. Oleh karena itu, rencanakan dan menyetujui migrasi Anda dengan hati-hati.

Dokumen ini adalah bagian dari rangkaian multi-bagian tentang migrasi ke Google Cloud. Jika Anda tertarik dengan ringkasan dari rangkaian tersebut, lihat Migrasi ke Google Cloud: Memilih jalur migrasi.

Dokumen ini adalah bagian dari rangkaian yang membahas memigrasi containers ke Google Cloud:

Memigrasikan container ke Google Cloud: Memigrasikan Kubernetes ke Google Kubernetes Engine (GKE)
Memigrasikan container ke Google Cloud: Bermigrasi dari OpenShift ke GKE Enterprise
Memigrasikan container ke Google Cloud: Memigrasikan project OpenShift ke GKE Enterprise (dokumen ini)
Bermigrasi dari OpenShift ke GKE Enterprise: Memigrasikan OpenShift SCC ke Batasan Pengontrol Kebijakan

Dokumen ini berguna jika Anda berencana memigrasikan project OpenShift ke GKE Enterprise. Dokumen ini juga berguna jika Anda sedang mengevaluasi peluang untuk bermigrasi dan ingin mempelajari kemungkinan gambarannya.

Dokumen ini bergantung pada konsep yang dibahas dalam Migrasi ke Google Cloud: Memulai, dalam Memigrasikan container ke Google Cloud: Migrasi Kubernetes ke GKE, dalam Memigrasikan container ke Google Cloud: Bermigrasi dari OpenShift ke GKE Enterprise, dan dalam Praktik terbaik untuk networking GKE. Dokumen ini tertaut ke dokumen sebelumnya jika sesuai.

Panduan dalam dokumen ini mengasumsikan bahwa Anda ingin menjalankan migrasi lift-and-shift workload. Dalam migrasi lift-and-shift, Anda hanya menerapkan perubahan minimum yang diperlukan agar workload Anda dapat beroperasi di lingkungan GKE Enterprise target.

Untuk memigrasikan resource OpenShift ke GKE Enterprise, Anda harus memetakan dan mengonversinya ke resource Kubernetes yang setara. Dokumen ini menjelaskan migrasi resource konfigurasi project OpenShift berikut yang diperlukan untuk men-deploy dan mengoperasikan workload Anda ke GKE Enterprise:

Untuk memigrasikan konfigurasi project OpenShift dan resource terkait ke GKE Enterprise, sebaiknya lakukan hal berikut:

Ekspor deskripsi resource konfigurasi project OpenShift.
Petakan resource konfigurasi project OpenShift ke resource Kubernetes.
Buat resource Kubernetes yang dipetakan ke resource konfigurasi project OpenShift.
Mengelola resource Kubernetes menggunakan Config Sync.

Dokumen ini memberikan contoh tentang cara menyelesaikan langkah-langkah migrasi.

Mengekspor deskripsi resource konfigurasi project OpenShift

Untuk mengekspor resource konfigurasi project OpenShift, sebaiknya Anda melakukan hal berikut:

Ekspor deskripsi project OpenShift.
Ekspor deskripsi resource khusus cluster.
Ekspor deskripsi resource khusus project.

Deskripsi yang Anda ekspor dari cluster OpenShift mencakup kolom yang mendeskripsikan konfigurasi dan status resource, seperti kolom spec dan status. Deskripsi tersebut juga mencakup kolom yang menyimpan informasi status resource, seperti kolom metadata.managedFields. Kubernetes dan OpenShift mengelola kolom yang menyimpan informasi status resource beserta nilainya untuk Anda. Untuk menyederhanakan penilaian deskripsi resource OpenShift, sebaiknya Anda melakukan hal berikut untuk setiap deskripsi resource:

Catat kolom yang menyimpan informasi status resource yang dihasilkan secara dinamis beserta nilainya seperti berikut:
- Setiap kolom bertingkat di bawah metadata.annotations yang diawali dengan awalan openshift.io
- metadata.creationTimestamp
- metadata.generation
- metadata.managedFields
- metadata.resourceVersion
- metadata.selfLink
- metadata.uid
- status
Hapus kolom yang menyimpan informasi status resource yang dihasilkan secara dinamis dari deskripsi resource.

Untuk mengekspor deskripsi resource konfigurasi project OpenShift, Anda dapat menggunakan Antarmuka command line OpenShift (oc CLI). Untuk mengekspor deskripsi resource di CLI oc, Anda perlu melakukan autentikasi dengan peran admin cluster. Untuk daftar semua resource OpenShift yang didukung oleh CLI oc, jalankan perintah oc api-resources.

Mengekspor deskripsi project OpenShift

Bagian ini menjelaskan tentang cara mengekspor deskripsi project. Sebaiknya Anda mengecualikan project OpenShift yang menjalankan komponen sistem, seperti komponen istio-system, dan mengecualikan project OpenShift yang memiliki nama yang dimulai dengan openshift-, kube-, atau knative-. OpenShift mengelola project OpenShift ini untuk Anda, dan project tersebut berada di luar cakupan migrasi ini karena Anda tidak menggunakannya untuk men-deploy workload. Untuk mengekspor deskripsi project OpenShift, lakukan hal berikut untuk setiap cluster OpenShift:

Di terminal yang memiliki akses ke cluster OpenShift, dapatkan daftar project OpenShift dengan menggunakan perintah oc get:
```
oc get projects
```
Outputnya mirip dengan hal berikut ini:
```
NAME                 DISPLAY NAME      STATUS
example-project                        Active
...
```
Output akan menampilkan daftar project OpenShift yang saat ini disiapkan di cluster OpenShift Anda.
Untuk setiap project OpenShift dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file menggunakan perintah tee, untuk diproses nanti. Misalnya, ekspor deskripsi project OpenShift example-project:
```
oc get project example-project -o yaml | tee project-example-project.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: project.openshift.io/v1
kind: Project
metadata:
  annotations:
  name: example-project
spec:
  finalizers:
  - kubernetes
```
Output akan menampilkan deskriptor project OpenShift example-project dalam format file YAML. Output akan disimpan ke file project-example-project.yaml.

Mengekspor deskripsi resource khusus cluster

Bagian ini menjelaskan tentang cara mengekspor deskripsi untuk resource yang memiliki cakupan cluster, tidak termasuk batasan konteks keamanan. Untuk informasi tentang memigrasikan kebijakan keamanan, lihat Bermigrasi dari OpenShift ke GKE Enterprise: Memigrasikan OpenShift SCC ke Batasan Pengontrol Kebijakan. Untuk mengekspor deskripsi resource lainnya, lakukan hal berikut untuk setiap cluster OpenShift:

Di terminal Anda, dapatkan daftar ClusterResourceQuotas:
```
oc get clusterresourcequotas
```
Output-nya mirip dengan yang berikut ini:
```
NAME       AGE
for-name   6m15s
for-user   4s
...
```
Output akan menampilkan daftar ClusterResourceQuotas yang saat ini disiapkan di cluster OpenShift Anda.
Untuk setiap ClusterResourceQuota dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi ClusterResourceQuota for-name:
```
oc get clusterresourcequota for-name -o yaml | tee clusterresourcequota-for-name.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: quota.openshift.io/v1
kind: ClusterResourceQuota
metadata:
  name: for-name
spec:
  quota:
    hard:
      pods: "10"
      secrets: "20"
  selector:
    annotations: null
    labels:
      matchLabels:
        name: frontend
```
Output akan menampilkan deskripsi ClusterResourceQuota for-name dalam format YAML. Output akan disimpan ke file clusterresourcequota-for-name.yaml.
Dapatkan daftar ClusterRoles:
```
oc get clusterroles
```
Outputnya mirip dengan hal berikut ini:
```
NAME                           CREATED AT
admin                          2021-02-02T06:17:02Z
aggregate-olm-edit             2021-02-02T06:17:59Z
aggregate-olm-view             2021-02-02T06:18:01Z
alertmanager-main              2021-02-02T06:48:26Z
basic-user                     2021-02-02T06:26:42Z
...
```
Output akan menampilkan daftar ClusterRole yang saat ini disiapkan di cluster OpenShift Anda. Daftar ClusterRole mencakup ClusterRole default OpenShift, dan ClusterRole yang merujuk ke komponen sistem OpenShift. Sebaiknya Anda menilai semua ClusterRoles dalam daftar untuk mengevaluasi peran mana yang perlu Anda migrasikan, dan peran mana yang tidak berlaku di lingkungan GKE Enterprise target.

Untuk setiap ClusterRole dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi ClusterRole admin:

oc get clusterrole admin -o yaml | tee clusterrole-admin.yaml

Outputnya mirip dengan hal berikut ini:

aggregationRule:
  clusterRoleSelectors:
  - matchLabels:
      rbac.authorization.k8s.io/aggregate-to-admin: "true"
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: admin
rules:
- apiGroups:
  - operators.coreos.com
  resources:
  - subscriptions
  verbs:
  - create
  - update
  - patch
  - delete
...

Output akan menampilkan deskripsi ClusterRole admin dalam format YAML. Output akan disimpan ke file clusterrole-admin.yaml.

Dapatkan daftar ClusterRoleBindings:

oc get clusterrolebindings

Outputnya mirip dengan hal berikut ini:

NAME                                        ROLE                                             AGE
alertmanager-main                           ClusterRole/alertmanager-main                    21d
basic-users                                 ClusterRole/basic-user                           21d
cloud-credential-operator-rolebinding       ClusterRole/cloud-credential-operator-role       21d
cluster-admin                               ClusterRole/cluster-admin                        21d
cluster-admins                              ClusterRole/cluster-admin                        21d
cluster-autoscaler                          ClusterRole/cluster-autoscaler                   21d
cluster-autoscaler-operator                 ClusterRole/cluster-autoscaler-operator          21d
cluster-monitoring-operator                 ClusterRole/cluster-monitoring-operator          21d
...

Output akan menampilkan daftar ClusterRoleBinding yang saat ini disiapkan di cluster OpenShift Anda. Daftar ClusterRoleBinding mencakup ClusterRoleBinding yang merujuk ke komponen sistem OpenShift. Sebaiknya Anda menilai semua ClusterRoleBinding dalam daftar untuk mengevaluasi binding mana yang perlu dimigrasikan, dan binding mana yang tidak berlaku di lingkungan GKE Enterprise target.

Untuk setiap ClusterRoleBinding dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi ClusterRoleBinding cluster-admin:

oc get clusterrolebinding cluster-admin -o yaml | tee clusterrolebinding-cluster-admin.yaml

Outputnya mirip dengan hal berikut ini:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: cluster-admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- apiGroup: rbac.authorization.k8s.io
  kind: Group
  name: system:masters

Output akan menampilkan deskripsi ClusterRoleBinding cluster-admin dalam format YAML. Output akan disimpan ke file clusterrolebinding-cluster-admin.yaml.

Mengekspor NetNamespace yang disesuaikan

Bagian ini menjelaskan cara menilai konfigurasi isolasi multi-tenant. Bagian ini berlaku jika Anda membuat NetNamespaces yang disesuaikan untuk project OpenShift apa pun di cluster Anda agar dapat mengisolasi atau bergabung ke namespace jaringan. Jika Anda tidak membuat NetNamespace yang disesuaikan, lanjutkan ke Mengekspor deskripsi resource khusus project.

OpenShift secara otomatis membuat dan mengelola NetNamespace untuk project OpenShift terkelola. NetNamespace untuk project yang dikelola OpenShift berada di luar cakupan migrasi ini.

Untuk mengekspor NetNamespace yang disesuaikan, lakukan hal berikut:

Dapatkan daftar NetNamespace:

oc get netnamespaces

Output-nya mirip dengan yang berikut ini.

NAME                                          NETID      EGRESS IPS
default                                       0
kube-node-lease                               13240579
kube-public                                   15463168
kube-system                                   16247265
openshift                                     9631477
openshift-apiserver                           12186643
openshift-apiserver-operator                  6097417
openshift-authentication                      2862939
openshift-authentication-operator             723750
openshift-cloud-credential-operator           11544971
openshift-cluster-csi-drivers                 7650297
openshift-cluster-machine-approver            7836750
openshift-cluster-node-tuning-operator        7531826
...

Output akan menampilkan daftar NetNamespace yang saat ini disiapkan di cluster OpenShift Anda.

Untuk setiap NetNamespace dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi default NetNamespace:
```
oc get netnamespace example-project -o yaml | tee netnamespace-example-project.yaml
```
Untuk NetNamespace yang tidak memiliki nilai netid yang sama, output-nya mirip dengan berikut ini:
```
apiVersion: network.openshift.io/v1
kind: NetNamespace
metadata:
  name: example-project
netid: 1234
netname: example-project
```
Output akan menampilkan deskripsi NetNamespace example-project dalam format file YAML. Output akan disimpan ke file netnamespace-example-project.yaml.

Untuk NetNamespace yang memiliki nilai netid yang sama, output-nya mirip dengan berikut ini:
```
apiVersion: network.openshift.io/v1
kind: NetNamespace
metadata:
  name: example-project
netid: 1234
netname: example-project

apiVersion: network.openshift.io/v1
kind: NetNamespace
metadata:
  name: example-project-2
netid: 1234
netname: example-project-2
```

Mengekspor deskripsi resource khusus project

Guna mengekspor deskripsi untuk resource yang memiliki cakupan project, lakukan langkah berikut untuk setiap project OpenShift.

Di terminal Anda, pilih project OpenShift yang ingin Anda nilai. Misalnya, pilih project OpenShift example-project:
```
oc project example-project
```
Dapatkan daftar ResourceQuotas:
```
oc get resourcequotas
```
Outputnya mirip dengan hal berikut ini:
```
NAME        AGE   REQUEST                        LIMIT
gpu-quota   6s    requests.nvidia.com/gpu: 1/1
...
```
Output akan menampilkan daftar ResourceQuotas yang saat ini disiapkan di cluster OpenShift untuk project OpenShift yang dipilih.
Untuk setiap ResourceQuota dalam daftar, ekspor deskripsinya dalam format YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya ekspor deskripsi ResourceQuota gpu-quota:
```
oc get resourcequota gpu-quota -o yaml | tee resourcequota-gpu-quota.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-quota
  namespace: example-project
spec:
  hard:
    requests.nvidia.com/gpu: "1"
```
Output akan menampilkan deskripsi ResourceQuota gpu-quota dalam format file YAML. Output akan disimpan ke file resourcequota-gpu-quota.yaml.
Dapatkan daftar Roles:
```
oc get roles
```
Outputnya mirip dengan hal berikut ini:
```
NAME             CREATED AT
example          2021-02-02T06:48:27Z

...
```
Output akan menampilkan daftar Peran yang saat ini disiapkan di cluster OpenShift untuk project OpenShift yang dipilih. Daftar Peran mencakup Peran yang merujuk pada komponen sistem OpenShift. Sebaiknya Anda menilai semua Peran dalam daftar untuk mengevaluasi peran mana yang perlu Anda migrasikan, dan peran mana yang tidak berlaku di lingkungan GKE Enterprise target.
Untuk setiap Peran dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya ekspor deskripsi Peran example:
```
oc get role example -o yaml | tee role-example.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: example
  namespace: example-project
rules:
- apiGroups:
  - ""
  resources:
  - services
  - endpoints
  - pods
  verbs:
  - get
  - list
  - watch
```
Output akan menampilkan deskripsi Peran example dalam format file YAML. Output akan disimpan ke file role-example.yaml.

Dapatkan daftar RoleBindings:

oc get rolebindings

Output-nya mirip dengan yang berikut ini:

NAME                               ROLE                                           AGE
machine-config-controller-events   ClusterRole/machine-config-controller-events   21d
machine-config-daemon-events       ClusterRole/machine-config-daemon-events       21d
example                            Role/example                                   21d
system:deployers                   ClusterRole/system:deployer                    21d
system:image-builders              ClusterRole/system:image-builder               21d
system:image-pullers               ClusterRole/system:image-puller                21d
...

Output akan menampilkan daftar RoleBinding yang disiapkan di cluster OpenShift untuk project OpenShift yang dipilih. Daftar RoleBinding mencakup RoleBinding yang merujuk ke komponen sistem OpenShift. Sebaiknya Anda menilai semua RoleBinding dalam daftar untuk mengevaluasi binding mana yang perlu Anda migrasikan, dan binding mana yang tidak berlaku di lingkungan GKE Enterprise target.

Untuk setiap RoleBinding dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya ekspor deskripsi RoleBinding example:
```
oc get rolebinding example -o yaml | tee rolebinding-example.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: example
  namespace: example-project
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: example
subjects:
- kind: ServiceAccount
  name: example
  namespace: example-ns
```
Output akan menampilkan deskripsi RoleBinding example dalam format file YAML. Output akan disimpan ke file rolebinding-example.yaml.
Dapatkan daftar EgressNetworkPolicies:
```
oc get egressnetworkpolicies
```
Outputnya mirip dengan hal berikut ini:
```
NAME      AGE
default   2m2s
...
```
Output akan menampilkan daftar EgressNetworkPolicy yang saat ini disiapkan di cluster OpenShift untuk project OpenShift yang dipilih.
Untuk setiap EgressNetworkPolicy dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi EgressNetworkPolicy default:
```
oc get egressnetworkpolicy default -o yaml | tee egressnetworkpolicy-default.yaml
```
Outputnya mirip dengan hal berikut ini:
```
apiVersion: network.openshift.io/v1
kind: EgressNetworkPolicy
metadata:
  name: default
  namespace: example-project
spec:
  egress:
  - to:
      cidrSelector: 1.2.3.0/24
    type: Allow
  - to:
      dnsName: www.example.com
    type: Allow
  - to:
      cidrSelector: 0.0.0.0/0
    type: Deny
```
Output akan menampilkan deskripsi EgressNetworkPolicy default dalam format YAML. Output juga akan disimpan ke file egressnetworkpolicy-default.yaml.
Dapatkan daftar NetworkPolicies:
```
oc get networkpolicies
```
Outputnya mirip dengan hal berikut ini:
```
NAME          POD-SELECTOR   AGE
test-policy   app=mongodb    3s
...
```
Output akan menampilkan daftar NetworkPolicy yang saat ini disiapkan di cluster OpenShift untuk project OpenShift yang dipilih.

Untuk setiap NetworkPolicy dalam daftar, ekspor deskripsinya dalam format file YAML, tampilkan output, dan simpan ke file untuk diproses nanti. Misalnya, ekspor deskripsi NetworkPolicy test-policy:

oc get networkpolicy test-policy -o yaml | tee networkpolicy-test-policy.yaml

Outputnya mirip dengan hal berikut ini:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-policy
  namespace: example-project
spec:
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: app
    ports:
    - port: 27017
      protocol: TCP
  podSelector:
    matchLabels:
      app: mongodb
  policyTypes:
  - Ingress

Output akan menampilkan deskripsi NetworkPolicytest-policy dalam file format YAML. Output akan disimpan ke file networkpolicy-test-policy.yaml.

Memetakan resource konfigurasi project OpenShift ke resource Kubernetes

Setelah menyelesaikan inventaris resource konfigurasi project OpenShift, Anda akan menilai resource tersebut sebagai berikut:

Evaluasi resource mana dalam inventaris yang merupakan resource Kubernetes dan resource mana saja yang merupakan resource OpenShift.
Petakan resource OpenShift ke Kubernetes, GKE, dan GKE Enterprise yang setara.

Daftar berikut membantu Anda untuk mengevaluasi resource mana yang Anda sediakan di cluster OpenShift yang merupakan resource Kubernetes dan resource mana yang hanya tersedia di OpenShift:

Project OpenShift adalah Namespace Kubernetes dengan anotasi tambahan.
Peran, ClusterRole, RoleBinding, dan ClusterRoleBinding adalah resource Kubernetes.
ResourceQuota adalah resource Kubernetes.
NetworkPolicy adalah resource Kubernetes.
ClusterResourceQuota bukan termasuk resource Kubernetes, dan hanya tersedia di OpenShift.
NetNamespace dan EgressNetworkPolicy bukan termasuk resource Kubernetes, dan hanya tersedia di OpenShift.

Tabel berikut berisi ringkasan cara memetakan resource konfigurasi project OpenShift ke resource yang Anda gunakan di GKE Enterprise.

OpenShift	GKE Enterprise
Project	Melakukan konversi ke Namespace Kubernetes dengan anotasi tambahan
Peran, ClusterRole, RoleBinding, dan ClusterRoleBinding	resource RBAC Kubernetes
ResourceQuotas	resource RBAC Kubernetes
ClusterResourceQuotas	Melakukan konversi ke ResourceQuotas atau menggunakan kuota resource hierarkis
NetworkPolicies	resource jaringan Kubernetes
NetNamespace, EgressNetworkPolicy	Konversi ke NetworkPolicies

Setelah mengevaluasi resource dari lingkungan OpenShift, petakan resource OpenShift ke resource yang dapat Anda sediakan dan konfigurasi di GKE dan GKE Enterprise. Anda tidak perlu memetakan resource Kubernetes yang digunakan di cluster OpenShift karena GKE Enterprise mendukungnya secara langsung. Seperti yang dijelaskan di Ringkasan pemetaan kapabilitas OpenShift ke GKE Enterprise, sebaiknya petakan hal berikut:

Project OpenShift ke Namespace Kubernetes.
ClusterResourceQuota ke ResourceQuota.
NetNamespace dan EgressNetworkPolicy ke NetworkPolicy.

Membuat resource Kubernetes yang dipetakan ke resource konfigurasi project OpenShift

Setelah menyelesaikan pemetaan, buatlah resource Kubernetes yang telah Anda petakan ke resource OpenShift. Sebaiknya Anda membuat hal berikut:

Satu Namespace Kubernetes untuk setiap project OpenShift
Satu ResourceQuota untuk setiap Namespace Kubernetes yang dibatasi oleh ClusterResourceQuota Anda
NetworkPolicy agar cocok dengan NetNamespace dan EgressNetworkPolicy

Membuat Namespace Kubernetes

Project OpenShift adalah Namespace Kubernetes dengan anotasi tambahan. API project OpenShift sangat cocok dengan API Namespace Kubernetes. Untuk memigrasikan project OpenShift, sebaiknya Anda membuat Namespace Kubernetes untuk setiap project OpenShift. API ini bersifat kompatibel sehingga Anda dapat membuat Namespace Kubernetes dari project OpenShift.

Untuk membuat Namespace Kubernetes dari project OpenShift, sebaiknya ubah nilai dalam deskripsi project OpenShift menjadi versi API Namespace Kubernetes yang sesuai untuk setiap project OpenShift. Untuk melakukannya, ubah nilai kolom apiVersion dalam deskripsi project OpenShift dari versi API objek project OpenShift dan nilai kolom kind ke Versi API objek Namespace Kubernetes yang sesuai. Misalnya, project OpenShift yang Anda nilai di bagian sebelumnya mirip dengan yang berikut:

apiVersion: project.openshift.io/v1
kind: Project
metadata:
  annotations:
  name: default
spec:
  finalizers:
  - kubernetes

Untuk memigrasikan project tersebut, ubah nilai kolom apiVersion dari project.openshift.io/v1 menjadi v1 dan ubah nilai kolom kind dari Project menjadi Namespace:

apiVersion: v1
kind: Namespace
Metadata:
  annotations:
  name: default
spec:
  finalizers:
  - kubernetes

Membuat ResourceQuota Kubernetes

ClusterResourceQuota OpenShift memungkinkan Anda berbagi kuota ke beberapa project OpenShift. Saat membuat ClusterResourceQuota, Anda harus menentukan kuota dan pemilih untuk mencocokkan project OpenShift yang kuotanya ingin Anda terapkan. Pada bagian ini, Anda akan memigrasikan ClusterResourceQuota OpenShift ke ResourceQuota Kubernetes di Namespace yang telah Anda buat sebelumnya.

Untuk memigrasikan ClusterResourceQuota, sebaiknya lakukan hal berikut untuk setiap ClusterResourceQuota:

Petakan ClusterResourceQuota ke project OpenShift dengan menilai kolom spec.quota dan kolom spec.selector ClusterResourceQuota. Misalnya, ClusterResourceQuota for-name yang telah Anda ekspor di bagian sebelumnya terlihat seperti berikut:
```
apiVersion: quota.openshift.io/v1
kind: ClusterResourceQuota
metadata:
  name: for-name
spec:
  quota:
    hard:
      pods: "10"
      secrets: "20"
  selector:
    annotations: null
    labels:
      matchLabels:
        name: frontend
```
ClusterResourceQuota for-name menerapkan batas kuota Pod dan Secret. Kolom spec.selector menerapkan batas tersebut pada project OpenShift frontend.
Pada bagian Membuat Namespace Kubernetes, Anda telah membuat Namespace Kubernetes yang sesuai dengan project OpenShift Anda. Gunakan informasi tersebut untuk memetakan ClusterResourceQuota ke Namespace Kubernetes baru. Misalnya, project OpenShift frontend berisi ClusterResourceQuota for-name. Project ini berkaitan dengan Namespace Kubernetes frontend sehingga Anda perlu memetakan ClusterResourceQuota for-name ke Namespace Kubernetes frontend.
Untuk setiap definisi kuota di kolom quota pada ClusterResourceQuota, bagi jumlah kuota di antara Namespace Kubernetes yang menjadi tujuan pemetaan ClusterResourceQuota Anda, sesuai dengan kriteria minat. Misalnya, Anda dapat membagi jumlah kuota yang ditetapkan oleh ClusterResourceQuota for-name secara merata untuk Namespace Kubernetes frontend.
Untuk setiap Namespace Kubernetes yang dipetakan ke ClusterResourceQuota, Anda perlu membuat ResourceQuota Kubernetes yang menerapkan kuota pada Namespace tersebut. Anda dapat menetapkan jumlah kuota sesuai dengan informasi yang telah Anda kumpulkan pada langkah sebelumnya. Misalnya, Anda membuat ResourceQuota untuk Namespace Kubernetes frontend:
```
apiVersion: v1
kind: ResourceQuota
metadata:
  name: pods-secrets
  namespace: frontend
spec:
  hard:
    pods: "10"
    secrets: "20"
```
Sebagai contoh lainnya, Anda memetakan ClusterResourceQuota for-name ke dua Namespace Kubernetes yang berbeda, example-1 dan example-2. Untuk menyelesaikan pemetaan, bagi resource secara merata dengan membuat ResourceQuota untuk Namespace Kubernetes. Alokasikan paruh pertama ResourceQuota:
```
apiVersion: v1
kind: ResourceQuota
metadata:
  name: pods-secrets
  namespace: example-1
spec:
  hard:
    pods: "5"
    secrets: "10"
```
Setelah mengalokasikan paruh pertama ResourceQuota, alokasikan paruh kedua ResourceQuota:
```
apiVersion: v1
kind: ResourceQuota
metadata:
  name: pods-secrets
  namespace: example-2
spec:
  hard:
    pods: "5"
    secrets: "10"
```
Dengan pendekatan ini, Anda dapat menerapkan batas di setiap Namespace Kubernetes tempat Anda membuat ResourceQuota, bukan menetapkan satu batas untuk beberapa Kubernetes Namespaces.

Menggunakan ResourseQuota untuk menerapkan kuota di Namespace Kubernetes Anda tidak sama dengan menggunakan ClusterResourceQuota untuk menerapkan satu kuota di semua Namespace Kubernetes. Membagi kuota khusus cluster di antara Namespace Kubernetes yang berbeda mungkin kurang optimal: pembagian tersebut mungkin memberikan kuota yang berlebihan untuk beberapa Namespace Kubernetes, dan menyebabkan kekurangan kuota untuk Namespace Kubernetes lainnya.

Sebaiknya, optimalkan alokasi kuota dengan menyesuaikan konfigurasi ResourceQuota di Namespace Kubernetes Anda secara dinamis, dengan memperhatikan jumlah total kuota yang ditetapkan oleh ClusterResourceQuota. Misalnya, Anda dapat menambah atau mengurangi jumlah kuota yang diberlakukan oleh ResourceQuota pods-secrets untuk menghindari jumlah kuota yang terlalu banyak atau terlalu sedikit untuk Namespace Kubernetes example-1 dan example-2. Jumlah total kuota ResourceQuota pods-secrets tidak boleh melebihi jumlah kuota di ClusterResourceQuota terkait.

Saat mengonfigurasi ResourceQuotas, pertimbangkan kuota dan batas GKE serta kuota dan batas GKE pada VMware. Kuota dan batas ini mungkin menerapkan batas yang lebih rendah daripada ResourceQuota Anda. Misalnya, GKE membatasi jumlah maksimum Pod per node, terlepas dari cara Anda mengonfigurasi ResourceQuota.

Membuat NetworkPolicy

NetNamespace OpenShift memungkinkan Anda mengonfigurasi isolasi jaringan antar-project OpenShift. EgressNetworkPolicy OpenShift memungkinkan Anda mengatur traffic keluar yang muncul dari cluster OpenShift. Bagian ini bergantung pada konsep pembatasan traffic.

Untuk memigrasikan NetNamespace dan TrafficNetworkPolicy, lakukan langkah berikut:

Lakukan penilaian pada NetNamespace dan EgressNetworkPolicy untuk memahami cara keduanya mengatur traffic jaringan antara project OpenShift dan traffic keluar yang muncul dari cluster OpenShift. Misalnya, nilai NetNamespace dan EgressNetworkPolicy yang telah Anda ekspor di bagian sebelumnya:
```
apiVersion: network.openshift.io/v1
kind: NetNamespace
metadata:
  name: example-project
netid: 1234
netname: example-project

apiVersion: network.openshift.io/v1
kind: NetNamespace
metadata:
  name: example-project-2
netid: 1234
netname: example-project-2

apiVersion: network.openshift.io/v1
kind: EgressNetworkPolicy
metadata:
  name: default
  namespace: example-project
spec:
  egress:
  - to:
      cidrSelector: 1.2.3.0/24
    type: Allow
  - to:
      cidrSelector: 0.0.0.0/0
    type: Deny
```
NetNamespace example-project dan example-project-2 menentukan jaringan overlay dengan nilai netid yang sama dengan1234. Oleh karena itu, Pod dalam project OpenShift example-project dapat berkomunikasi dengan Pod dalam project OpenShift example-project-2, dan sebaliknya.

EgressNetworkPolicy default menetapkan aturan traffic jaringan keluar berikut:
- Mengizinkan traffic keluar ke subnet 1.2.3.0/24
- Menolak traffic keluar yang tidak cocok dengan aturan lain

Buatlah kebijakan NetworkPolicy dan OPA agar sesuai dengan persyaratan pembatasan traffic jaringan Anda. Misalnya, default-np dan default-np-2 menerapkan kebijakan berikut:

Kebijakan yang diterapkan oleh EgressNetworkPolicy default
Kebijakan yang diterapkan oleh NetNamespace example-project dan example-project-2 pada Namespace yang memiliki label netid yang ditetapkan ke example-project dan example-project-2:

Kebijakannya mirip dengan berikut ini:

---
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: default-np
  namespace: example-project
spec:
  policyTypes:
  - Ingress
  - Egress
  podSelector: {}
  egress:
    - to:
      - namespaceSelector:
          matchLabels:
            netid: example-project-2
      - podSelector: {}
      - ipBlock:
          cidr: 1.2.3.0/24
  ingress:
    - from:
      - namespaceSelector:
          matchLabels:
            netname: example-project-2

---
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: default-np-2
  namespace: example-project-2
spec:
  policyTypes:
  - Ingress
  - Egress
  podSelector: {}
  egress:
    - to:
      - namespaceSelector:
          matchLabels:
            netid: example-project-2
      - podSelector: {}
      - ipBlock:
          cidr: 1.2.3.0/24
  ingress:
    - from:
      - namespaceSelector:
          matchLabels:
            netname: example-project

Mengelola resource Kubernetes menggunakan Config Sync

Untuk mengelola resource Kubernetes dan konfigurasi cluster GKE, sebaiknya gunakan Config Sync.

Untuk mempelajari cara mengaktifkan Config Sync pada cluster GKE Anda, lihat Menginstal Config Sync.

Setelah menyediakan dan mengonfigurasi Config Sync di lingkungan GKE Enterprise, Anda dapat menggunakannya untuk membuat dan menerapkan konfigurasi secara otomatis ke cluster GKE.

Langkah selanjutnya

Baca cara memulai migrasi ke Google Cloud.
Baca praktik terbaik untuk membuat dan mengoperasikan container.
Pelajari praktik terbaik untuk jaringan GKE.
Pahami cara memperkuat keamanan cluster.
Baca ringkasan keamanan GKE.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.