
OpenShift-แแก แแแแแฎแ แแแ แกแแ แจแแแแ แแแแ แชแแขแ แฎแแแก แฌแแ แแแแแแแแ. แแแแแแแแ แ แแแ แกแแ 4.3 แฎแแแแแกแแฌแแแแแแ แแแแแ แแก แแแแแแแ แแ แแแกแจแ แจแแขแแแแแ แงแแแแ แชแแแแแแแ แแ แกแ แฃแแแแ แแฎแแแแ, แ แแช แแแกแแแ แแแ แกแแแจแ แแ แแงแ, แแ 4.1 แแแ แกแแแจแ แแ แกแแแฃแแ แแแคแแ แแแชแแแก แแแแจแแแแแแแแแ แแแแแฎแแแแแ. แงแแแแแคแแ แ, แ แแกแแช แแฎแแ แแแขแงแแแ, แฃแแแ แแชแแแแก, แแแแแแก แแ แแแแแแแแแกแฌแแแแก แแแ, แแแแช OpenShift-แแแ แแฃแจแแแแก แแ แแฎแแ แแแ แกแแแแ แแแแแกแแแแก แแแแแแแก.
OpenShift 4.2-แแก แแแแแจแแแแแ, Red Hat-แแ แแแแแแ แขแแแ Kubernetes-แแแ แแฃแจแแแแ. แแแแแฉแแแ แแฎแแแ แแแกแขแ แฃแแแแขแแแ แแ แแแแแแแขแแแ แแแแขแแแแแ แแแแก, CI/CD แแแแกแแแแแแแแก แแ แกแแ แแแ แแก แแแ แแจแ แแแแแแแแแแก แจแแกแแฅแแแแแแ. แแแแแแชแแแแ แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแแแ แแแก, แงแฃแ แแแฆแแแ แแแแแแฎแแแแแ แแแแแก แฌแแ แแแ แแ แแ แ Kubernetes-แแแ แแฃแจแแแแแก แแแ แแแแแแแ.
แแแจ, แ แ แกแแแฎแแแแแแ OpenShift 4.2-แกแ แแ 4.3-แจแ?
แฐแแแ แแแฃแแ แฆแ แฃแแแแแแกแแแ แกแแแ
แแฎแแแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแแแกแแก แแ แแ แกแแแฃแแ IT แแแแแจแแคแขแแก แแแแแแแแ แแแแกแแก, แแแแแแแแแแ แกแฃแ แฃแคแ แ แฎแจแแ แแ แแแแแฎแแแแแแ แฆแ แฃแแแแแแ แแแแแแแแก IT แ แแกแฃแ แกแแแแก แแแฌแแแแแแกแแแแก, แ แแกแแแแกแแช แแกแแแ แแแ แแแแแ แแแ แซแ แฆแ แฃแแแแแแ แแแแแฌแงแแแขแแแแแแแก แแ แแงแแแแแแ แกแแฏแแ แ แฆแ แฃแแแแแแแ แแ แแแแแแแ แแแแก แจแแกแแซแแแแแแแแแก. แแแ แแแแ, แแแแแแแแ แแแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แแแ แกแฃแ แฃแคแ แ แแแขแแ แแแแแฃแแแ โแฐแแแ แแแฃแโ แฆแ แฃแแแแแแ แแแแแแแ, แ แแแแกแแช แแแแแแงแแแแแ แ แแแแ แช แแแแแแแแ แแแ แ แแกแฃแ แกแแแ, แแกแแแ แกแแฏแแ แ แฆแ แฃแแแแแแแ แ แแกแฃแ แกแแแ แกแแแ แแ แแแ แแแแก แกแแกแขแแแแ. Red Hat OpenShift 4.2 แกแแแชแแแแฃแ แแ แจแแฅแแแแแแ แฐแแแ แแแฃแ แฆแ แฃแแแแแแ แแแแแแแ แแแแแกแแแแก แแแกแแแแ แขแแแแแแแ แแ แกแแจแฃแแแแแแก แแแซแแแแ แแแ แขแแแแ แแแแแแแจแแ แแ แ แแกแฃแ แกแแแ แแกแแแ แแ แแแแแแแ แแแแกแแแ, แ แแแแ แแชแแ AWS, Azure แแ Google Cloud Platform, แแแแกแขแแ แแแ, VMware-แกแ แแ OpenStack-แแ แแแ แซแ แฆแ แฃแแแแแแก แแแแแงแแแแแแกแแแ แแ แแแ.
แแแกแขแแแแชแแแก แแฎแแแ แแแแแแแ
OpenShift-แแก แแแกแขแแแแชแแแก แแแแแแแ แจแแแชแแแแ แแ-4 แแแ แกแแแจแ. Red Hat แแแแแแแแแ แกแแแชแแแแฃแ แฃแขแแแแขแแก OpenShift แแแแกแขแแ แแก แแแแกแแแแแกแแแแแ - openshift-install. แฃแขแแแแขแ แฌแแ แแแแแแแแก Go-แจแ แแแฌแแ แแ แแ แ แแแแแ แฃแ แคแแแแก. Openshit-installer แแแแแแแแก yaml แคแแแแก แแแแกแแแแแกแแแแแ แกแแญแแ แ แแแแคแแแฃแ แแชแแแ.
แฆแ แฃแแแแแแแ แ แแกแฃแ แกแแแแก แแแแแงแแแแแแ แแแกแขแแแแชแแแก แจแแแแฎแแแแแจแ, แแฅแแแ แฃแแแ แแแฃแแแแแ แแแแแแแแ แแแแกแขแแ แแก แจแแกแแฎแแ แแแแแแแแฃแ แ แแแคแแ แแแชแแ: DNS แแแแ, แแฃแจแ แแแแแซแแแแก แ แแแแแแแแ, แฆแ แฃแแแแแแแ แแ แแแแแแแ แแก แกแแแชแแคแแแฃแ แ แแแ แแแแขแ แแแ, แฆแ แฃแแแแแแ แแ แแแแแแแ แแ แฌแแแแแแก แแแแแ แแจแแก แแแแแชแแแแแ. แแแแคแแแฃแ แแชแแแก แคแแแแแก แแแแแแแแแแก แจแแแแแ, แแแแกแขแแ แแก แแแแแแแกแแแ แจแแกแแซแแแแแแแ แแ แแ แแ แซแแแแแแ.
แกแแแฃแแแ แแแแแแแแแ แ แแกแฃแ แกแแแแ แแแกแขแแแแชแแแก แจแแแแฎแแแแแจแ, แแแแแแแแแ, แแแ แซแ แฆแ แฃแแแแก แแแแแงแแแแแแกแแก (แแฎแแ แแแญแแ แแแแ vSphere แแ OpenStack) แแ แจแแจแแแแ แแแขแแแแก แกแแ แแแ แแแแ แแแกแขแแแแชแแแกแแก, แกแแญแแ แ แแฅแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฎแแแแ แแแแคแแแฃแ แแชแแ - แแแแแแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแ แคแแแแแฃแ แ แกแแ แแแ แแแแก แแแแแแแแฃแ แ แ แแแแแแแแ, แ แแแแแแแช แกแแญแแ แแ Control Plane แแแแกแขแแ แแก แจแแกแแฅแแแแแแ, แแแแแแแคแแแฃแ แแ แแ แฅแกแแแฃแ แ แกแแ แแแกแแแ. แแกแแแ แแแแคแแแฃแ แแชแแแก แจแแแแแ, OpenShift แแแแกแขแแ แแก แจแแฅแแแ แจแแกแแซแแแแแแแ แแแแแแแแฃแ แแ openshift-installer-แแก แแ แแ แแ แซแแแแแแ.
แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแฎแแแแแแ
แแแขแแแ แแชแแ CoreOS-แแแ
แแแแแแ แ แแแแแฎแแแแ Red Hat CoreOS-แแแ แแแขแแแ แแชแแแ. แแฎแแ Red Hat OpenShift-แแก แแแแแแ แ แแแแแซแแแแก แแแจแแแแแ แจแแกแแซแแแแแแ. แแฎแแแแ แแฎแแ แแแแ แแชแแฃแ แกแแกแขแแแแแ. แแก แแ แแก Red Hat-แแก แฃแคแแกแ แแแแ แแชแแฃแแ แกแแกแขแแแ, แ แแแแแแช แกแแแชแแแแฃแ แแ แแแแขแแแแแ แฃแแ แแแแแฌแงแแแขแแแแแแแแกแแแแกแแ แจแแฅแแแแแ. Red Hat CoreOS แแกแฃแแฃแฅแแ Linux, แแแขแแแแแแแฃแแแ แแแแขแแแแแ แแแแก แแแกแแจแแแแแ.
แแฃ 3.11 แแแ แกแแแจแ แแแแ แแชแแฃแแ แกแแกแขแแแ แแ OpenShift แชแแแแ แแ แกแแแแแแ, แแแจแแ 4.2 แแแ แกแแแจแ แแก แแแแฃแงแแคแแแ แแ แแก แแแแแแจแแ แแแฃแแ OpenShift-แแแ. แแฎแแ แแก แแ แแแแแ แแแฌแงแแแแแแแแ - แฃแชแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ.

แแ แแแแกแขแแ แแแแกแแแแก, แ แแแแแแแช แงแแแแ แแแแแซแแกแแแแก RHCOS-แก แแงแแแแแแ, OpenShift Container Platform-แแก แแแแแฎแแแแ แแแ แขแแแ แแ แแแฆแแ แแแขแแแแขแแแแ แแแฃแแ แแ แแชแแกแแ.
แแแ แ, OpenShift-แแก แแแแแฎแแแแแกแแแแก, แฏแแ แฃแแแ แแแแแฎแแแแฃแแแงแ แซแแ แแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแ, แ แแแแแแแช แแ แแแฃแฅแขแ แแฃแจแแแแแ (แแ แแ แแก แแก แแงแ Red Hat Enterprise). Linuxแแฎแแแแ แแแแก แจแแแแแ แจแแแซแแแแแแ OpenShift-แแก แแแแแแแแแแแแ แแแแแฎแแแแ, แแแแแซแแแแ แแแแแซแแแแ. แแ แแชแแกแแก แแแขแแแแขแแแแชแแแแ แกแแฃแแแ แ แแ แงแแคแแแ.
แแฎแแ, แ แแแแแ OpenShift Container Platform-แก แแฅแแก แกแ แฃแแ แแแแขแ แแแ แแแแแแฃแ แแแแแซแแ แแ แกแแแฃแ แกแแกแขแแแแแกแ แแ แกแแ แแแกแแแแ, แแแ แจแแ แแก แแแแ แแชแแฃแ แกแแกแขแแแแแ, แแก แแแแชแแแ แกแ แฃแแแแแ แแแ แแแขแแ แคแแแกแแแแ แฆแแแแแแ แแแญแแ แแ. แแแแก แจแแแแแ, OpenShift แแแแกแขแแ แจแ แแฎแกแแแแ แกแแแชแแแแฃแ แ แแแแ แแขแแ แ, แ แแแแแแช แแแ แแแแก แแแแ แแแแแฎแแแแแก แแ แแชแแกแก.
แแฎแแแ CSI
แแแแ แ แแ แแก แแฎแแแ CSI โ แจแแแแฎแแแก แแแขแแ แคแแแกแแก แแแแขแ แแแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแจแแ แแ แกแฎแแแแแกแฎแแ แแแ แ แจแแแแฎแแแก แกแแกแขแแแแแ OpenShift แแแแกแขแแ แแแ. แแฎแแ แแแญแแ แแแแ OpenShift-แแกแแแแก แจแแแแฎแแแก แแ แแแแแ แแแแก แแแแ แ แแแแแแแแ, แ แแแแแแแช แแแคแฃแซแแแแฃแแแ แแแแแ แจแแแแฎแแแก แกแแกแขแแแแแแก แแฌแแ แแแแแแแแแก แแแแ แแแฌแแ แแ แจแแแแฎแแแก แแ แแแแแ แแแแ. แแฎแแ แแแญแแ แแแ CSI แแ แแแแแ แแแแก แกแ แฃแแ แกแแ แจแแแแซแแแแ แแฎแแแแ แแ แแแแฃแแแแขแจแ: แแก แกแแ แแแแชแแแก แฌแแแงแแแแ แแฌแแ แแแแแแแแแก (Dell/EMC, IBM, NetApp, Hitachi, HPE, PureStorage), SDS แแแแแฌแงแแแขแแแแแแแแก (Ceph) แแ แฆแ แฃแแแแแแแ แกแแชแแแแก (AWS, Azure, Google) แงแแแแ แซแแ แแแแ แแแกแแแก แแแกแแแแก แแแแแแก. OpenShift 4.2 แแฎแแ แก แฃแญแแ แก CSI แกแแแชแแคแแแแชแแแก 1.1 แแแ แกแแแก CSI แแ แแแแแ แแแก.
RedHat OpenShift แกแแ แแแกแแก แแแแ
Istio-แก, Kiali-แก แแ Jaeger-แแก แแ แแแฅแขแแแแ แแแคแฃแซแแแแฃแแ Red Hat OpenShift Service Mesh, แกแแ แแแกแแแก แจแแ แแก แแแแฎแแแแแแแก แแแ แจแ แฃแขแแแแชแแแก แฉแแแฃแแแแ แแแ แแแแชแแแแแแก แแแ แแ, แกแแจแฃแแแแแแก แแซแแแแ แแแแฎแแแแแแแก แแแแแงแฃแ แแก แแแแแแแแกแ แแ แแแแฃแแแแแแชแแแก. แแก แแฎแแแ แแแ แแแแแแแแแ แแแก Red Hat OpenShift-แจแ แแแแแแแแแฃแแ แแแแแแแชแแแแแก แฃแ แแแแ แแฅแแแแแแแก, แแแแแแ แแแแแกแ แแ แแแ แแแแก แแแแแ แขแแแแแแจแ.

แแแแ แแกแแ แแแกแแก แแ แฅแแขแแฅแขแฃแ แแก แแแแแงแแแแแแ แแแแแแแชแแแก แแแแฃแแแแแแชแแ Kiali-แก แแแแแงแแแแแแ
Service Mesh-แแก แแแกแขแแแแชแแแก, แแแแแ-แแแขแ แแแแแแกแ แแ แกแแกแแชแแชแฎแแ แชแแแแแก แแแ แแแแก แแแฅแกแแแแแฃแ แแ แแแกแแแแ แขแแแแแแแ, Red Hat OpenShift แแแแแแแกแขแ แแขแแ แแแก แกแแแแแแแแก แกแแแชแแแแฃแ แแแแ แแขแแ แก - Service Mesh แแแแ แแขแแ แก. แแก แแ แแก Kubernetes แแแแ แแขแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแแกแแ แแแแกแขแแ แจแ แแแแแแแแคแแแฃแ แแ แแแฃแแ Istio, Kiali แแ Jaeger แแแแแขแแแ, แ แแช แแแฅแกแแแแแฃแ แแ แแแชแแ แแแก แแแแแแแกแขแ แแชแแฃแ แขแแแ แแก แแแแแแแชแแแแแก แแแ แแแแกแแแ.
CRI-O Docker-แแก แแแชแแแแ
แแแแฃแแแกแฎแแแแ แแแแขแแแแแ แแก แแแจแแแแแก แแ แ Docker-แ CRI-O-แแ แจแแแชแแแแ. CRI-O แฃแแแ แฎแแแแแกแแฌแแแแแ แแงแ 3.11 แแแ แกแแแจแ, แแแแ แแ 4.2-แจแ แแก แแแแแแ แ แแแฎแแ. แแ แช แแแ แแแ แแ แแ แช แชแฃแแ, แแแแ แแ แแ แแแฃแฅแขแแก แแแแแงแแแแแแกแแก แแแกแแแแแแแกแฌแแแแแแแแ.
แแแแ แแขแแ แแแ แแ แแแแแแแชแแแแแก แแแแแแแแแ
แแแแ แแขแแ แแแ RedHat OpenShift-แแก แแฎแแแ แแ แแแฃแแแ, แ แแแแแแช แแ-4 แแแ แกแแแจแ แแฅแแ แฌแแ แแแแแแแแแ. แแกแแแ Kubernetes แแแแแแแชแแแก แจแแคแฃแแแแก, แแแแแแแแแแกแ แแ แแแ แแแแก แแแแแแก แฌแแ แแแแแแแแแ. แฌแแ แแแแแแแแแ แแกแแแ, แ แแแแ แช Kubernetes API-แกแ แแ kubectl แแแกแขแ แฃแแแแขแแแแก แแแจแแแแแแ แแแ แแฃแแ แแแแขแแแแแ แแแแแฃแแ แแแแแแแชแแแแแก แแแแแแแขแ.
Kubernetes-แแก แแแแ แแขแแ แแแ แฎแแแก แฃแฌแงแแแแ แแฅแแแแก แแแแกแขแแ แจแ แแแแแแแแแฃแ แแแแแแแชแแแก แแแแแแแกแขแ แแ แแแแกแแแ แแ แกแแกแแชแแชแฎแแ แชแแแแแก แแแ แแแแกแแแ แแแแแแจแแ แแแฃแแ แแแแแกแแแแ แ แแแแแแแแแก แแแขแแแแขแแแแชแแแก. แแแแแแแแแ, แแแแ แแขแแ แก แจแแฃแซแแแ แแแแแแแชแแแก แแแแแฎแแแแแแแก, แกแแ แแแแ แแ แแกแแแแแก แจแแฅแแแแกแ แแ แแแกแจแขแแแแ แแแแก แแแขแแแแขแแแแชแแ, แแแแคแแแฃแ แแชแแแก แจแแชแแแ แแ แ.แจ. แแแแ แแขแแ แแแแก แกแ แฃแแ แกแแ แจแแแแซแแแแ แแฎแแแแ แจแแแแแ แแแฃแแแ: .
OperatorHub-แแ แฌแแแแแ แฃแจแฃแแแแ แแแ แแแแก แแแแกแแแแก แแแ แแแขแแ แคแแแกแแแแ แแ แแก แจแแกแแซแแแแแแ. แแก แแ แแก Red Hat-แแก แแแแ แแฎแแ แแแญแแ แแแ OpenShift-แแก แแแแแแแชแแแแแก แแแขแแแแแ. แแก แแแจแแแแก, แ แแ Red Hat-แแก แแแแ แแแแขแแแชแแแฃแแ แงแแแแ แแแแ แแขแแ แ แแแแชแแแแแแ แแแแฌแแแแแแแก แแฎแแ แแแญแแ แแก.

OperatorHub แแแ แขแแแ OpenShift-แแก แแแ แแแแก แแแแกแแแจแ
แฃแแแแแ แกแแแฃแ แ แแแแแก แกแฃแ แแแ
แแก แแ แแก RHEL OS-แแก แกแฃแ แแแแแแก แกแขแแแแแ แขแแแแแฃแแ แแแแ แแแ, แ แแแแแก แแแแแงแแแแแแช แจแแแแซแแแแ แแแแขแแแแแ แแแแแฃแแ แแแแแแแชแแแแแก แจแแกแแฅแแแแแแ. แแ แกแแแแแก แแแแแแแแฃแ แ, แกแขแแแแแ แขแฃแแ แแ แกแ แฃแแ แแแแ แแแแแ. แแกแแแ แซแแแแแ แชแแขแ แแแแแแก แแแแแแแแ, แแฎแแ แก แฃแญแแ แแ แงแแแแ แกแแญแแ แ แแแแแกแขแแแแ แแแฃแ แแแแแขแก แแ แแ แแแ แแแแ แแแแก แแแแก.
CI/CD แแแกแขแ แฃแแแแขแแแ
RedHat OpenShift 4.2 แฌแแ แแแแแแแแแ Tekton Pipelines-แแก แแแแ แแฎแแ แแแญแแ แแ Jenkins-แกแ แแ OpenShift-แแก แแแแกแแแแแแแก แจแแ แแก แแ แฉแแแแก แจแแกแแซแแแแแแแแก.
OpenShift Pipelines แแแคแฃแซแแแแฃแแแ Tekton-แแ, แ แแแแแแช แฃแแแ แฃแญแแ แก แแฎแแ แก Pipeline-แก Code-แแกแ แแ GitOps-แแก แแแแฎแแแแแแกแแแ แแ แแแ. OpenShift-แแก แแแแกแแแแแแแจแ แแแแแแฃแแ แแแแแฏแ แกแแแฃแแแ แแแแขแแแแแ แจแ แแฃแจแแแแก, แแแแขแแ แ แแกแฃแ แกแแแ แแแแแแงแแแแแ แแฎแแแแ แแแแแฏแแก แจแแกแ แฃแแแแแก แแ แแก. แแก แแแแแแแแแ แแแก แกแ แฃแ แแแแขแ แแแก แแซแแแแก แแแแฃแแแแแก แแแฌแแแแแแก แแแแกแแแแแแแแ, แแแแแแแขแแแกแ แแ แฌแแแแแแก แแแแขแ แแแแ แชแแแขแ แแแฃแ แ CI/CD แกแแ แแแ แแก แแแ แแแแก แแแ แแจแ.
OpenShift Pipelines แแแแแแแ แแแแแแแแแ แแแแกแแแแก แฌแแแแกแฌแแ แ แแแแแฎแแแแแก แ แแแแแจแแ แแ แฎแแแแแกแแฌแแแแแแ แแแแ แแขแแ แแก แกแแฎแแ OpenShift 4 แแแแกแขแแ แแ. แ แ แแฅแแ แฃแแแ, OpenShift-แแก แแแแฎแแแ แแแแแแก แแแแแ แจแแฃแซแแแแ Jenkins-แแก แแแแแงแแแแแ RedHat OpenShift 4-แแ.
แแแแแแแแแ แแแแก แแแ แแแแก แแแแแฎแแแแแแ
OpenShift 4.2-แก แแฅแแก แกแ แฃแแแแ แแแแแแแแแแฃแแ แแแ แแแขแแ แคแแแกแ แ แแแแ แช แแแแแแแแแ แแแแกแแแแก, แแกแแแ แแแแแแแกแขแ แแขแแ แแแแกแแแแก.
OpenShift-แแก แฌแแแ แแแ แกแแแแจแ แงแแแแ แแฃแจแแแแแ แกแแ แแแแกแแแจแ: แกแแ แแแกแแแแก แแแขแแแแแจแ, แแแแแแแกแขแ แแขแแ แแก แแแแกแแแกแ แแ แกแแแฃแจแแ แแแแกแแแจแ. แแฎแแ แแแแกแขแแ แ แแแงแแคแแแแ แแฎแแแแ แแ แแแฌแแแแ - แแแแแแแกแขแ แแขแแ แแก แแแแกแแแแ แแ แแแแแแแแแ แแก แแแแกแแแแ.
แแแแแแแแแ แแก แแแแกแแแแ แแแแจแแแแแแแแแ UI แแแฃแแฏแแแแกแแแแแ แแแแฆแ. แแก แแฎแแ แฃแคแ แ แแแ แขแแแแ แแฉแแแแแแก แแแแแแแชแแแแแกแ แแ แแกแแแแแแแก แขแแแแแแแแแแก. แแก แแแแแแแแแ แแแก แแแแแแแแแก แแแแขแแแแแ แแแแแฃแแ แแแแแแแชแแแแแกแ แแ แแแแกแขแแ แฃแแ แ แแกแฃแ แกแแแแก แจแแฅแแแแก, แแแแแแแแแแก แแ แแแแฃแแแแแแชแแแก. แแก แแแ แกแแจแฃแแแแแแก แแซแแแแก, แงแฃแ แแแฆแแแ แแแแแแฎแแแแแ แแแแแ, แ แแช แแแแแแแก แแแแจแแแแแแแแแแ.

แแแแแแแแแ แแก แแแ แขแแแ OpenShift-แแก แแแ แแแแก แแแแกแแแจแ
แแแ
Odo แแ แแก แแแแแแแแแ แแแแ แแ แแแแขแแ แแแฃแแ แแ แซแแแแแแก แฎแแแแก แแ แแแ แแแ, แ แแแแแแช แแแแ แขแแแแแก แแแแแแแชแแแแแก แจแแแฃแจแแแแแแก OpenShift-แแ. git push แกแขแแแแก แฃแ แแแแ แแฅแแแแแแแก แแแแแงแแแแแแ, แแก CLI แแฎแแแ แแแ Kubernetes-แแก แแฎแแแแแแ แแแแแแแแแ แแแก OpenShift-แแ แแแแแแแชแแแแแก แจแแฅแแแแจแ.
แแแขแแแ แแชแแ แแแแแแแแ แแแแก แแแ แแแแกแแแ
แแแแแแแแแ แแแก แแฎแแ แจแแฃแซแแแแ แจแแฅแแแแ, แแแแแ แแแ แแ แแแแแแแแกแแ แแแแแแแแ แแแแแแแชแแแแ OpenShift-แแ แกแแงแแแ แแแ แแแแแ แแแแก แแแ แแแแแแ แแแฃแกแแแแแแ, แ แแแแ แแชแแ Microsoft Visual Studio, JetBrains (แแแ แจแแ แแก IntelliJ), Eclipse Desktop แแ แ.แจ.
Red Hat OpenShift Deployment แแแคแแ แแแแแ Microsoft Azure DevOps-แแกแแแแก
Microsoft Azure DevOps-แแกแแแแก Red Hat OpenShift Deployment แแแคแแ แแแแแ แฃแแแ แฎแแแแแกแแฌแแแแแแ. แแ DevOps แแแกแขแ แฃแแแแขแแ แแฃแแแก แแแแฎแแแ แแแแแแก แแฎแแ แจแแฃแซแแแแ แแแแแแแแ แแแแแแแชแแแแแก Azure Red Hat OpenShift-แแ แแ แแแแแกแแแแ แกแฎแแ OpenShift แแแแกแขแแ แแ แแแ แแแแแ Microsoft Azure DevOps-แแแ แแแแแแแแกแแ.
แแแแแกแแแ แแแกแแแ แแแ แกแแแแแ แแแแแฎแแแ
แ แแแแแ แฉแแแ แแกแแฃแแ แแแ แแฎแแ แแแแแจแแแแแแ แแ แแ แ แแแแแฎแแแแแแ, แแฅแแแ แแ แจแแแแซแแแแ แฃแแ แแแแ แแแแแฎแ แแแ แกแแแก แแแกแขแแแแชแแ แแแกแแแแแ. แแแ แกแแ 3-แแแ แแแ แกแแ 4-แแ แแแแแฎแแแแ แแฎแแ แแแญแแ แแแ แแ แแฅแแแแ..
แแแแ แแ แแแ แแ แแแแแแแ: Red Hat แแแแแแแแแ แแแกแขแ แฃแแแแขแแแก แแ แแแฅแขแแแแก 3.7 แแแ แกแแแแแ 4.2 แแแ แกแแแแแ แแแแ แแชแแแกแแแแก. แแฅแแแ แจแแแแซแแแแ แแแแแแแชแแแก แกแแแฃแจแแ แแแขแแแ แแแแก แแแแ แแชแแ แแแแกแขแแ แฃแแ แแแแแแแชแแแก แแแแ แแชแแแก (CAM) แแแกแขแ แฃแแแแขแแก แแแแแงแแแแแแ. CAM แกแแจแฃแแแแแแก แแแซแแแแ แแแแแขแ แแแแ แแแแ แแชแแ แแ แแแแแแฃแแแแแ แแแแงแแแแแ แแแแแแแชแแแก แจแแคแแ แฎแแแ.
OpenShift 4.3
แแ แกแขแแขแแแจแ แแฆแฌแแ แแแ แซแแ แแแแแ แกแแแฎแแแแแ 4.2 แแแ แกแแแจแ แแแแแฉแแแ. แแฎแแแฎแแ แแแแแจแแแแฃแ 4.3 แแแ แกแแแจแ แแแแแแแแ แแแแจแแแแแแแแแ แชแแแแแแแแแแ, แแฃแแชแ แ แแแแแแแแ แกแแแฎแแ แแแแแช แแ แแก. แชแแแแแแแแแแก แกแแ แกแแแแแแ แแ แชแแแแ, แฉแแแแ แแแ แแ, แแฅ แงแแแแแแ แแแแจแแแแแแแแแ แแแงแแแแแแแ:
แแแแแแฎแแแ Kubernetes-แแก แแแ แกแแ 1.16-แแแ.
แแแ แกแแ แแ แแแ แแฃแแแ แแ แ แแแแแฏแแ แแแแแฎแแแ, โโOpenShift 4.2-แจแ แแก 1.14 แแงแ.
แแแแแชแแแแ แแแจแแคแแ แ etcd-แจแ
4.3 แแแ แกแแแแแ แแแฌแงแแแฃแแ, แแฎแแ แจแแกแแซแแแแแแแ etcd แแแแแชแแแแ แแแแแจแ แแแแแชแแแแแแก แแแจแแคแแ แ. แแแจแแคแแ แแก แฉแแ แแแแก แจแแแแแ, แแแจแแคแ แฃแแ แแฅแแแแ แจแแแแแแ OpenShift API แแ Kubernetes API แ แแกแฃแ แกแแแ: Secrets, ConfigMaps, Routes, access tokens แแ OAuth แแแขแแ แแแแชแแ.
แกแแญแแกแแแ
แแแแแแขแ แแฎแแ แแแญแแ แ Helm แแแ แกแแ 3-แแกแแแแก, Kubernetes-แแก แแแแฃแแแ แฃแแ แแแแแขแแแแก แแแแแฏแแ แแกแแแแก. แแ แแขแแแแ แแฎแแ แแแญแแ แแก แแฅแแก TECHNOLOGY PREVIEW แกแขแแขแฃแกแ. OpenShift-แแก แแแแแแแ แแแ แกแแแแจแ Helm-แแก แแฎแแ แแแญแแ แ แกแ แฃแแแ แแแคแแ แแแแแแแ. helm cli แฃแขแแแแขแ แแแงแแแแ OpenShift-แก แแ แแแกแ แฉแแแแขแแแ แแแ แจแแกแแซแแแแแแแ แแแแกแขแแ แแก แแแ แแแแก แแแ แแแแกแแแแแแ.
แแ แแแฅแขแแก แกแแแแคแแ แแแชแแ แแแคแแก แแแแแฎแแแแ
แแฎแแ แแแ แกแแแจแ, แแ แแแฅแขแแก แแแคแ แแแแแขแแแแ แแแคแแ แแแชแแแก แแแแฌแแแแก แแ แแแฅแขแแก แแแแ แแแ: แแ แแแฅแขแแก แกแขแแขแฃแกแ, แ แแกแฃแ แกแแแแก แแแแแงแแแแแ แแ แแ แแแฅแขแแก แแแแขแแแ.
แแแ แแแแกแแแจแ quay-แก แแแฃแชแแแแแแแแแก แฉแแแแแแ
แแแ แแแแก แแแแกแแแก แแฎแแ แแฅแแก แคแฃแแฅแชแแ Quay แ แแแแแแขแแ แแแจแ แแ แกแแแฃแแ แกแฃแ แแแแแแกแแแแก แชแแแแแแ แแแฃแชแแแแแแแแแก แกแแฉแแแแแแแแ. แแฎแแ แแแญแแ แแแแ แ แแแแ แช แแแแแแแแ แแแ, แแกแแแ แแแ แ แ แแแแแแขแแ แแแแก แแแฃแชแแแแแแแแแก แฉแแแแแแ.
แแคแแแแ แแแแ แแขแแ แแก แฐแแแแก แแแแแ แขแแแแแฃแแ แจแแฅแแแ
OpenShift แแแแกแขแแ แแก แแแแแแ แแแฃแ แฅแกแแแจแ แแแแแแแแแแก แจแแแแฎแแแแแจแ, แกแแแแแแแช แแแขแแ แแแขแแ แฌแแแแแ แจแแแฆแฃแแฃแแแ แแ แกแแแ แแแ แแ แแ แกแแแแแก, OperatorHub แ แแแกแขแ แแก โแกแแ แแแกโ แจแแฅแแแ แแแแแ แขแแแแ. แแฎแแ แแก แแฎแแแแ แกแแแ แแ แซแแแแแแ แจแแแซแแแแ แแแแแแแแก.
แฒแแขแแ แแแ:
แแแฅแขแแ แแฃแฉแแแแ, แแฃแ แ แกแแแแแแฃแแแแ
แฌแงแแ แ: www.habr.com
