OpenShift-แแก แแแแแฎแ แแแ แกแแ แจแแแแ แแแแ แชแแขแ แฎแแแก แฌแแ แแแแแแแแ. แแแแแแแแ แ แแแ แกแแ 4.3 แฎแแแแแกแแฌแแแแแแ แแแแแ แแก แแแแแแแ แแ แแแกแจแ แแ แกแแแฃแแ แงแแแแ แชแแแแแแแ แแ แแก แกแ แฃแแแแ แแฎแแแ, แ แแช แแ แแงแ แแแกแแแ แแแ แกแแแจแ, แแ แซแแ แแแแแ แแแแแฎแแแแ แแแแกแ, แ แแช แแแแแฉแแแ 4.1 แแแ แกแแแจแ. แงแแแแแคแแ แ, แ แแกแแช แแฎแแ แแแขแงแแแ, แฃแแแ แแชแแแแก, แแแแแแก แแ แแแแแแแแแกแฌแแแแก แแแ, แแแแช แแฃแจแแแแก OpenShift-แแแ แแ แแแแแแแก แแฎแแ แแแ แกแแแแ แแแแแกแแแแก.
OpenShift 4.2-แแก แแแแแจแแแแแ Red Hat-แแ แแแแแแแแแ Kubernetes-แแแ แแฃแจแแแแ. แแแแแฉแแแ แแฎแแแ แฎแแแกแแฌแงแแแแ แแ แแแแแแแขแแแ แแแแขแแแแแ แแแแก, CI/CD แแแแกแแแแแแแแก แแ แกแแ แแแ แแก แแแ แแจแ แแแแแแแแแแก แจแแกแแฅแแแแแแ. แแแแแแชแแแแ แแซแแแแก แแแแแแแแแ แแแก แจแแกแแซแแแแแแแแก, แงแฃแ แแแฆแแแ แแแแแแฎแแแแแ แแแแแก แแแฌแแ แแแ แแ แแ แ แแฃแแแ แแแขแแแแแ แฃแ แแแแ แแแแแแ.
แกแแแแแแแแแแจแ, แ แ แแ แแก แแฎแแแ OpenShift 4.2 แแ 4.3 แแแ แกแแแแจแ?
แแแแแแแแแแแแ แฐแแแ แแแฃแแ แฆแ แฃแแแแแแกแแแ
แแฎแแแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแแแแแกแแก แแ แแ แกแแแฃแแ IT แแแแแจแแคแขแแก แจแแแฃแจแแแแแแกแแก, แแแแแแแแแแ แกแฃแ แฃแคแ แ แฎแจแแ แแ แแแแแฎแแแแแแ แฆแ แฃแแแแแแ แแแแแแแแก IT แ แแกแฃแ แกแแแแก แฃแแ แฃแแแแแงแแคแแก แแแแแ แ, แ แแกแแแแกแแช แแกแแแ แแฎแแ แชแแแแแแแ แแแ แซแ แฆแ แฃแแแแแแ แแแแแฌแงแแแขแแแแแแแก แแ แแงแแแแแแ แกแแฏแแ แ แฆแ แฃแแแแแแแ แแ แแแแแแแ แแแแก แซแแแแก. แแแ แแแแ, แแแแแแแแ แแแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แ แกแฃแ แฃแคแ แ แแแขแแ แจแแแแแแ โแฐแแแ แแแฃแแโ แฆแ แฃแแแแแแแ แแแแแแแก แแแฎแแแแแ, แ แแแแกแแช แแแแแแงแแแแแ แ แแแแ แช แจแแแ แ แแกแฃแ แกแแแ, แแกแแแ แกแแฏแแ แ แฆแ แฃแแแแแแแ แ แแกแฃแ แกแแแ แกแแแ แแ แแแ แแแแก แกแแกแขแแแแ. Red Hat OpenShift 4.2 แกแแแชแแแแฃแ แแ แจแแฅแแแแแแ แฆแ แฃแแแแก แฐแแแ แแแฃแ แแแแแแแ แแแแแกแแแแก แแแกแแแแ แขแแแแแแแ แแ แแแแแแแแแก แ แแกแฃแ แกแแแแก แแแแแแจแแ แแแแก แแ แแแแแแแ แแแแกแแแ, แ แแแแ แแชแแ AWS, Azure แแ Google Cloud Platform แแแแกแขแแ แแแ, VMware-แกแ แแ OpenStack-แแ แแแ แซแ แฆแ แฃแแแแแแก แแแแแงแแแแแแกแแแ แแ แแแ.
แแแกแขแแแแชแแแก แแฎแแแ แแแแแแแ
แแ-4 แแแ แกแแแจแ แจแแแชแแแแ OpenShift-แแก แแแกแขแแแแชแแแก แแแแแแแ. Red Hat แแแแแแแแแ แกแแแชแแแแฃแ แแ แแแ แแแแก OpenShift แแแแกแขแแ แแก แแแแกแแแแแกแแแแแ - openshift-install. แแ แแแ แแแ แแ แแก แแ แแ แแ แแแแแ แคแแแแ, แ แแแแแแช แแแฌแแ แแแแ Go-แจแ. Openshit-installer แแแแแแแแก yaml แคแแแแก แแแแแแแแแแกแแแแก แกแแญแแ แ แแแแคแแแฃแ แแชแแแ.
แฆแ แฃแแแแแแแ แ แแกแฃแ แกแแแแก แแแแแงแแแแแแ แแแกแขแแแแชแแแก แจแแแแฎแแแแแจแ, แแแแแฌแแแ แแแฃแแแแแ แแแแแแแแฃแ แ แแแคแแ แแแชแแ แแแแแแแแ แแแแกแขแแ แแก แจแแกแแฎแแ: DNS แแแแ, แแฃแจแ แแแแแซแแแแก แ แแแแแแแแ, แฆแ แฃแแแแแแแ แแ แแแแแแแ แแก แกแแแชแแคแแแฃแ แ แแแ แแแแขแ แแแ, แแแแแ แแจแแก แแแคแแ แแแชแแ แฆแ แฃแแแแแแ แแ แแแแแแแ แแ แฌแแแแแแกแแแแก. แแแแคแแแฃแ แแชแแแก แคแแแแแก แแแแแแแแแแก แจแแแแแ, แแแแกแขแแ แ แจแแแซแแแแ แแแแแแแกแแแก แแ แแ แแ แซแแแแแแ.
แกแแแฃแแแ แแแแแแแแแ แ แแกแฃแ แกแแแแ แแแกแขแแแแชแแแก แจแแแแฎแแแแแจแ, แแแแแแแแแ, แแแ แแแ แฆแ แฃแแแแก แแแแแงแแแแแแกแแก (แแฎแแ แแแญแแ แแแแ vSphere แแ OpenStack) แแ แจแแจแแแแ แแแแแแแก แกแแ แแแ แแแแ แแแกแขแแแแชแแแกแแก, แแแแญแแ แแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฎแแแแ แแแแคแแแฃแ แแชแแ - แแแแแแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแแแแแแฃแ แ แ แแแแแแแแ แแ แคแแแแแฃแ แ แกแแ แแแ แแแ, แ แแแแแแแช แกแแญแแ แแ Control Plane แแแแกแขแแ แแก แจแแกแแฅแแแแแแ, แฅแกแแแแก แกแแ แแแกแแแแก แแแแคแแแฃแ แแชแแแกแแแแก. แแ แแแแคแแแฃแ แแชแแแก แจแแแแแ, OpenShift แแแแกแขแแ แ แแแแแแแแฃแ แแ แจแแแซแแแแ แจแแแฅแแแแก openshift-installer แแ แแแ แแแแก แแ แแ แแ แซแแแแแแ.
แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แแแแแฎแแแแแแ
CoreOS แแแขแแแ แแชแแ
แแแแแแ แ แแแแแฎแแแแ แแ แแก Red Hat CoreOS-แแแ แแแขแแแ แแชแแ. Red Hat OpenShift แแแกแขแแ แแแแแซแแแก แแฎแแ แจแแฃแซแแแแ แแแฃแจแแแ แแฎแแแแ แแฎแแ OS-แแ. แแก แแ แแก แฃแคแแกแ แแแแ แแชแแฃแแ แกแแกแขแแแ Red Hat-แแกแแแ, แ แแแแแแช แจแแฅแแแแแแ แกแแแชแแแแฃแ แแ แแแแขแแแแแ แแก แแแแแฌแงแแแขแแแแแแแแกแแแแก. Red Hat CoreOS แแ แแก แแกแฃแแฃแฅแ Linux แแแขแแแแแแ แแแฃแแ แแแแขแแแแแ แแแแก แแแจแแแแแกแแแแก.
แแฃ 3.11-แจแ แแแแ แแชแแฃแแ แกแแกแขแแแ แแ OpenShift แแ แกแแแแแแ แชแแแแ, แแแจแแ 4.2-แจแ แแก แแแแฃแงแแคแแแ แแ แแก แแแแแแจแแ แแแฃแแ OpenShift-แแแ. แแฎแแ แแก แแ แแก แแ แแ แแแฌแงแแแแแแแ - แฃแชแแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แ.
แแแแกแขแแ แแแแกแแแแก, แ แแแแแแแช แแงแแแแแแ RHCOS-แก แงแแแแ แแแแแซแแกแแแแก, OpenShift Container Platform-แแก แแแแแฎแแแแ แแแ แขแแแ แแ แฃแแฆแ แแกแแ แแแขแแแแขแแแแ แแแฃแแ แแ แแชแแกแแ.
แแแ แ, OpenShift-แแก แแแแแฎแแแแแกแแแแก, แแฅแแแ แฏแแ แฃแแแ แแแแแแฎแแแ แซแแ แแแแแ แแแแ แแชแแฃแแ แกแแกแขแแแ, แ แแแแแแแช แแ แแแฃแฅแขแ แแฃแจแแแแแ (แแ แแ แแก Red Hat Enterprise Linux). แแฎแแแแ แแแแก แจแแแแแ แจแแแซแแแแแแ OpenShift-แแก แแขแแแแแ แแแแ แแแแแฎแแแแ, แแแแแซแ แแแแแซแ. แแ แแชแแกแแก แ แแแแ แแแขแแแแขแแแแชแแแแ แกแแฃแแแ แ แแ แงแแคแแแ.
แแฎแแ, แ แแแแแ OpenShift แแแแขแแแแแ แแก แแแแขแคแแ แแ แกแ แฃแแแ แแแแแขแ แแแแแก แกแแกแขแแแแแกแ แแ แกแแ แแแกแแแก แแแแแแฃแ แแแแแซแแ, แแแ แจแแ แแก OS, แแก แแแแชแแแ แฌแงแแแแ แฆแแแแแแก แแแญแแ แแ แแแ แแแขแแ แคแแแกแแแแ. แแแแก แจแแแแแ, OpenShift แแแแกแขแแ แจแ แแฎแกแแแแ แกแแแชแแแแฃแ แ แแแแ แแขแแ แ, แ แแแแแแช แแแแแขแ แแแแแก แแแแแฎแแแแแก แแแแ แแ แแชแแกแก.
แแฎแแแ CSI
แแแแ แแช, แแฎแแแ CSI แแ แแก แจแแแแฎแแแก แแแขแแ แคแแแกแแก แแแแขแ แแแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแจแแ แแ แกแฎแแแแแกแฎแแ แแแ แ แจแแแแฎแแแก แกแแกแขแแแแแ OpenShift แแแแกแขแแ แแแ. OpenShift-แแกแแแแก แแแฎแกแแแ แแแแก แแ แแแแแ แแแแก แแ แแแแแแแ แแแแก แแแแ แ แแแแแแแแ แแฎแแ แแแญแแ แแแแ แแแฎแกแแแ แแแแก แแ แแแแแ แแแแก แกแแคแฃแซแแแแแ, แ แแแแแแแช แแแฌแแ แแแแ แแแแแ แจแแแแฎแแแก แกแแกแขแแแแก แแฌแแ แแแแแแแแแก แแแแ . แแฎแแ แแแญแแ แแแ CSI แแ แแแแแ แแแแก แกแ แฃแแ แกแแ แจแแแแซแแแแ แแฎแแแแ แแ แแแแฃแแแแขแจแ:
RedHat OpenShift แกแแ แแแกแแก แแแแ
Istio, Kiali แแ Jaeger แแ แแแฅแขแแแแ แแแคแฃแซแแแแฃแแ, Red Hat OpenShift Service Mesh, แกแแ แแแกแแแก แจแแ แแก แแแแฎแแแแแก แแแ แจแ แฃแขแแแแชแแแก แฉแแแฃแแแแ แแแ แแแแชแแแแแแก แแแ แแ, แแซแแแแ แแแแ แแแแแแแแแกแ แแ แแแแฃแแแแแแชแแแก แกแแจแฃแแแแแแก. แแก แแฎแแแ แแแ แแแแแแแแแ แแแก แแแแแแแ แแแฃแแแแจแแ แแแแ, แแแแแแแ แแแแ แแ แแแ แแแ แแแแแแแชแแ, แ แแแแแแช แแแแแแแแแฃแแแ Red Hat OpenShift-แจแ.
แแแแ แแกแแ แแแกแแก แแ แฅแแขแแฅแขแฃแ แแก แแฅแแแ แแแแแแแชแแแก แแแแฃแแแแแแชแแ Kiali-แก แแแแแงแแแแแแ
แกแแ แแแก Mesh-แแก แแแกแขแแแแชแแแก, แแแแแแกแ แแ แกแแกแแชแแชแฎแแ แชแแแแแก แแแ แแแแก แแแฅแกแแแแแฃแ แแ แแแแแ แขแแแแแแก แแแแแแ, Red Hat OpenShift แแแแแแแกแขแ แแขแแ แแแก แกแแแแแแแแก แกแแแชแแแแฃแ แแแแ แแขแแ แก, Service Mesh แแแแ แแขแแ แก. แแก แแ แแก Kubernetes แแแแ แแขแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแแกแแ แฎแแแแฎแแ แแแแคแแแฃแ แแ แแแฃแแ Istio, Kiali แแ Jaeger แแแแแขแแแ แแแแกแขแแ แแ, แ แแช แแแฅแกแแแแแฃแ แแ แแแแ แแแก แแแแแแแชแแแแแก แแแ แแแแก แแแแแแแกแขแ แแชแแฃแ แขแแแ แแก.
CRI-O แแแแแ แแก แแแชแแแแ
แแแแฃแแแกแฎแแแแ แแแแขแแแแแ แแก แแแจแแแแแก Docker แจแแแชแแแแ CRI-O-แแ. CRI-O-แก แแแแแงแแแแแ แฃแแแ 3.11 แแแ แกแแแจแ แแงแ แจแแกแแซแแแแแแ, แแแแ แแ 4.2-แจแ แแก แแแฎแแ แแแแแแ แ. แแ แแ แแก แแแ แแ แแ แชแฃแแ, แแแแ แแ แ แแฆแแช แฃแแแ แแแฎแกแแแแแ แแ แแแฃแฅแขแแก แแแแแงแแแแแแกแแก.
แแแแ แแขแแ แแแ แแ แแแแแแแชแแแแแก แแแแแแแแแ
แแแแ แแขแแ แแแ แแ แแก แแฎแแแ แแ แแแฃแแ RedHat OpenShift-แแกแแแแก, แ แแแแแแช แแแแแฉแแแ แแแแแฎแ แแแ แกแแแจแ. แแก แแ แแก Kubernetes แแแแแแแชแแแก แจแแคแฃแแแแก, แแแแแแแแแแก แแ แแแ แแแแก แแแแแแ. แแก แจแแแซแแแแ แฉแแแแแแแแก แแแแขแแแแแ แแแจแ แแแแแแแแแฃแแ แแแแแแแชแแแแแก แแแแแแแขแแ, แ แแแแแกแแช แฎแแแแซแฆแแแแแแแแก Kubernetes API แแ kubectl แแแกแขแ แฃแแแแขแแแ.
Kubernetes-แแก แแแแ แแขแแ แแแ แแแฎแแแ แแแแแ แแแขแแแแขแแแแ แแแแจแ แแแแแกแแแแ แ แแแแชแแแแก แแแขแแแแขแแแแชแแแจแ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ แแแแแแแชแแแก แแแแแแแกแขแ แแชแแแกแแแ แแ แกแแกแแชแแชแฎแแ แชแแแแแก แแแ แแแแกแแแ, แ แแแแแกแแช แแฅแแแ แแแแแแแแกแแแ แแฅแแแแก แแแแกแขแแ แจแ. แแแแแแแแแ, แแแแ แแขแแ แก แจแแฃแซแแแ แแแแแฎแแแแแแแก, แแแแแแแชแแแก แกแแ แแแแ แแ แแกแแแแแก แแ แกแแแแแ แแแแก แแแขแแแแขแแแแชแแ, แแแแคแแแฃแ แแชแแแก แจแแชแแแ แแ แ.แจ. แแแแ แแขแแ แแแแก แกแ แฃแแ แกแแ แจแแแแซแแแแ แแฎแแแแ แแฅ
OperatorHub แฎแแแแแกแแฌแแแแแแ แฃแจแฃแแแแ แแแ แแแแก แแแแกแแแแก แแแ แแแขแแ แคแแแกแแแแ. แแก แแ แแก แแแแแแแชแแแก แแแ แแฅแขแแ แแ OpenShift-แแกแแแแก, แ แแแแแกแแช แแแแฎแแแก Red Hat. แแแแ. แงแแแแ Red Hat แแแแขแแแชแแแฃแแ แแแแ แแขแแ แ แแแคแแ แฃแแ แแฅแแแแ แแแแงแแแแแแแก แแฎแแ แแแญแแ แแ.
OperatorHub แแแ แขแแแ OpenShift แแแ แแแแก แแแแกแแแจแ
แฃแแแแแ แกแแแฃแ แ แแแแแก แกแฃแ แแแ
แแก แแ แแก RHEL OS แกแฃแ แแแแแแก แกแขแแแแแ แขแแแแแฃแแ แแแแ แแแ, แ แแแแแแช แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แแฅแแแแ แแแแขแแแแแ แแ แแแฃแแ แแแแแแแชแแแแแก แจแแกแแฅแแแแแแ. แแ แแก แแแแแแแแฃแ แ, แกแขแแแแแ แขแฃแแ แแ แกแ แฃแแ แแแแแแแฅแขแแแ. แแกแแแ แซแแแแแ แแชแแ แ แแแแแแก แแแแแแแแ แแ แแฎแแ แก แฃแญแแ แแ แงแแแแ แกแแญแแ แ แแแแแกแขแแแแ แแแฃแ แแแแแขแก แแ แแ แแแ แแแแ แแแแก แแแแแก.
CI/CD แแแกแขแ แฃแแแแขแแแ
RedHat OpenShif 4.2-แจแ แจแแกแแซแแแแแแ แแแฎแแ แแ แฉแแแแแแก แแแแแแแแ Jenkins-แกแ แแ OpenShift Pipelines-แก แจแแ แแก Tekton Pipelines-แแก แกแแคแฃแซแแแแแ.
OpenShift Pipelines แแแคแฃแซแแแแฃแแแ Tekton-แแ, แ แแแแแกแแช แฃแแแแแกแแ แฃแญแแ แก แแฎแแ แก Pipeline, แ แแแแ แช Code แแ GitOps แแแแแแแแแ. OpenShift แแแแกแแแแแแแจแ, แแแแแแฃแแ แแแแแฏแ แแแแแก แกแแแฃแแแ แแแแขแแแแแ แจแ, แแแแขแแ แ แแกแฃแ แกแแแ แแแแแแงแแแแแ แแฎแแแแ แแแแแฏแแก แจแแกแ แฃแแแแแกแแก. แแก แแซแแแแก แแแแแแแแแ แแแก แกแ แฃแ แแแแขแ แแแก แแแแฃแแแก แแแฌแแแแแแก แแแแกแแแแแแแแ, แแแแแแแขแแแแ แแ แฌแแแแแแก แแแแขแ แแแแ แชแแแขแ แแแฃแ แ CI/CD แกแแ แแแ แแก แแแ แแแแก แแแ แแจแ.
OpenShift Pipelines แแแแแแแ Developer Preview-แจแแ แแ แฎแแแแแกแแฌแแแแแแ แ แแแแ แช แแแแ แแขแแ แ OpenShift 4 แแแแกแขแแ แแ, แ แ แแฅแแ แฃแแแ, OpenShift แแแแฎแแแ แแแแแแก แแแแแช แจแแฃแซแแแแ แแแแแแงแแแแ Jenkins RedHat OpenShift 4-แแ.
แแแแแแแแแ แแก แแแแแฏแแแแขแแก แแแแแฎแแแแแแ
4.2 OpenShift-แจแ แแแ แแแขแแ แคแแแกแ แแแแแแแแ แแแแแฎแแแ แ แแแแ แช แแแแแแแแแ แแแแกแแแแก, แแกแแแ แแแแแแแกแขแ แแขแแ แแแแกแแแแก.
OpenShift-แแก แฌแแแ แแแ แกแแแแจแ แงแแแแ แแฃแจแแแแแ แกแแ แแแแกแแแจแ: แกแแ แแแกแแก แแแ แแฅแขแแ แแแจแ, แแแแแแแกแขแ แแขแแ แแก แแแแกแแแจแ แแ แกแแแฃแจแแ แแแแกแแแจแ. แแฎแแ แแแแกแขแแ แ แแแงแแคแแแแ แแฎแแแแ แแ แแแฌแแแแ - แแแแแแแกแขแ แแขแแ แแก แแแแกแแแแ แแ แแแแแแแแแ แแก แแแแกแแแแ.
แแแแแแแแแ แแก แแแแกแแแแ แแแแฆแ แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแแก แแแแจแแแแแแแแแ แแแฃแแฏแแแแกแแแ. แแฎแแ แแก แฃแคแ แ แแแฎแแ แฎแแแฃแแแ แแฉแแแแแแก แแแแแแแชแแแแแก แขแแแแแแแแแแก แแ แแแ แจแแแ แแแแแก. แแก แแแแแแแแแก แแแแแแแแแ แแแก แแแแขแแแแแ แแ แแแฃแแ แแแแแแแชแแแแแก แแ แแแแกแขแแ แฃแแ แ แแกแฃแ แกแแแแก แจแแฅแแแแก, แแแแแ แแแแก แแ แแแแฃแแแแแแชแแแก. แกแแจแฃแแแแแแก แแซแแแแก แแแ แงแฃแ แแแฆแแแ แแแแแแฎแแแแแ แแแแแ, แ แแช แแแแแแแก แแแแจแแแแแแแแแแ.
แแแแแแแแแ แแก แแแ แขแแแ OpenShift แแแ แแแแก แแแแกแแแจแ
แแแ
Odo แแ แแก แแแแแแแแแ แแ แแ แแแแขแแ แแแฃแแ แแ แซแแแแแแก แฎแแแ, แ แแแแแแช แแแแ แขแแแแแก แแแแแแแชแแแก แจแแแฃแจแแแแแแก OpenShift-แจแ. git push แกแขแแแแก แแแแฃแแแแแชแแแก แแแแแงแแแแแแ, แแก CLI แแฎแแแ แแแ Kubernetes-แแก แแฎแแ แแแแแแแแแ แแแก OpenShift-แจแ แแแแแแแชแแแแแก แแจแแแแแแจแ.
แแแขแแแ แแชแแ แแแแแแแแ แแแแก แแแ แแแแกแแแ
แแแแแแแแแ แแแก แแฎแแ แจแแฃแซแแแแ แจแแฅแแแแ, แแแแแ แแแ แแ แแแแแแแแกแแ แแแแแแแแ แแแแแแแชแแแแ OpenShift-แจแ แแแแ แกแแงแแแ แแแ แแแแแก แแแแแแแแ แแแแก แแแ แแแแก แแแขแแแแแแก แแแ แแจแ, แ แแแแ แแชแแ Microsoft Visual Studio, JetBrains (แแแ แจแแ แแก IntelliJ), Eclipse Desktop แแ แ.แจ.
Red Hat OpenShift Deployment แแแคแแ แแแแแ Microsoft Azure DevOps-แแกแแแแก
แแแแแแแแ Red Hat OpenShift Deployment แแแคแแ แแแแแ Microsoft Azure DevOps-แแกแแแแก. แแ DevOps แแแกแขแ แฃแแแแขแแ แแแแ แแแแก แแแแฎแแแ แแแแแแก แแฎแแ แจแแฃแซแแแแ แแแแแแแแกแแ แแแแแแแแ แแแแแแแชแแแแ Azure Red Hat OpenShift-แจแ แแ แแแแแกแแแแ แกแฎแแ OpenShift แแแแกแขแแ แจแ แแแ แแแแแ Microsoft Azure DevOps-แแแ.
แแแกแแแ แแแ แกแแแแแ แแแแแฎแแแ แแแแแกแแแ
แแแแแแแแ แฉแแแ แแกแแฃแแ แแแ แแฎแแ แแแแแจแแแแแแ แแ แแ แ แแแแแฎแแแแแแ, แแฅแแแ แแ แจแแแแซแแแแ แฃแแ แแแแ แแแแงแแแแ แแแแแฎแ แแแ แกแแ แแแกแแแแแ. แแ-3 แแแ แกแแแแแ 4 แแแ แกแแแแแ แแแแแฎแแแแ แแ แแฅแแแแ แแฎแแ แแแญแแ แแแ..
แแแแ แแ แแ แแก แแแ แแ แแแแแแ: Red Hat แแแแแแแแแ แแแกแขแ แฃแแแแขแแแก แแ แแแฅแขแแแแก แแแแ แแชแแแกแแแแก 3.7-แแแ 4.2-แแแ. แจแแแแซแแแแ แแแแแแแชแแแก แแแขแแแ แแแแก แแแแ แแชแแ Cluster Application Migration (CAM) แแแกแขแ แฃแแแแขแแก แแแแแงแแแแแแ. CAM แกแแจแฃแแแแแแก แแแซแแแแ แแแแแขแ แแแแ แแแแ แแชแแ แแ แแแแแแฃแแแแแ แแแแงแแแแแ แแแแแแแชแแแก แจแแคแแ แฎแแแ.
OpenShift 4.3
แแ แกแขแแขแแแจแ แแฆแฌแแ แแแ แซแแ แแแแแ แแแแแแชแแแแ แแแแแฉแแแ 4.2 แแแ แกแแแจแ. แแฎแแแฎแแ แแแแแฅแแแงแแแแฃแแ 4.3 แชแแแแแแแแแ แแ แช แแฃ แแกแ แแแแแ, แแแแ แแ แฏแแ แแแแแ แแ แแก แ แแแแแแแแ แแฎแแแ แ แแ. แชแแแแแแแแแแก แกแแ แกแแแแแแ แแ แชแแแแ, แแฅ แแ แแก แงแแแแแแ แแแแจแแแแแแแแแ แฉแแแแ แแแ แแ:
แแแแแแฎแแแ Kubernetes แแแ แกแแ 1.16-แแ.
แแแ แกแแ แแแแแฎแแแ แแ แแแ แแฃแแแ แแ แ แแแแแฏแแ OpenShift 4.2-แจแ แแงแ 1.14.
แแแแแชแแแแ แแแจแแคแแ แ แแ แ.แจ
4.3 แแแ แกแแแ แแแฌแงแแแฃแแ, แจแแกแแซแแแแแแ แแแฎแแ แแแแแชแแแแแแก แแแจแแคแแ แ etcd แแแแแชแแแแ แแแแแจแ. แแแจแแคแแ แแก แฉแแ แแแแก แจแแแแแ, แจแแกแแซแแแแแแ แแฅแแแแ แจแแแแแแ OpenShift API แแ Kubernetes API แ แแกแฃแ แกแแแแก แแแจแแคแแ แ: Secrets, ConfigMaps, แแแ แจแ แฃแขแแแ, แฌแแแแแแก แแแจแแแแ แแ OAuth แแแขแแ แแแแชแแ.
แกแแญแแกแแแ
แแแแแแขแ แแฎแแ แแแญแแ แ Helm แแแ แกแแแกแแแแก 3, แแแแฃแแแ แฃแแ แแแแแขแแก แแแแแฏแแ แ Kubernetes-แแกแแแแก. แแ แแ แแแกแแแแก แแฎแแ แแแญแแ แแก แแฅแแก แกแขแแขแฃแกแ TECHNOLOGY PREVIEW. Helm แแฎแแ แแแญแแ แ แแแคแแ แแแแแแแ แกแ แฃแ แแฎแแ แแแญแแ แแแแ OpenShift-แแก แแแแแแแ แแแ แกแแแแจแ. แกแแญแ cli แฃแขแแแแขแแก แแแแฉแแแ OpenShift แแ แแแกแ แฉแแแแขแแแ แแแ แจแแกแแซแแแแแแแ แแแแกแขแแ แแก แแแ แแแแก แแแ แแแแกแแแแแแ.
แแ แแแฅแขแแก แแแคแแก แแแแแฎแแแแ
แแฎแแ แแแ แกแแแจแ, Project Dashboard แแแแแแแแแ แแแแแขแแแแ แแแคแแ แแแชแแแก แแ แแแฅแขแแก แแแแ แแแ: แแ แแแฅแขแแก แกแขแแขแฃแกแ, แ แแกแฃแ แกแแแแก แแแแแงแแแแแ แแ แแ แแแฅแขแแก แแแแขแแแ.
แแแแ แแแแกแแแจแ แแแแแกแแฎแฃแแแ แแแฃแชแแแแแแแก แฉแแแแแแ
แแแแแฏแแแแขแแก แแแแกแแแก แแแแแแขแ แคแฃแแฅแชแแ Quay แกแแชแแแแแจแ แแแแแกแแฎแฃแแแแแก แชแแแแแแ แแแฃแชแแแแแแแก แฉแแแแแแแกแแแแก. แแแแแแแแ แแแ แแ แแแ แ แกแแชแแแแแแกแแแแก แแแฃแชแแแแแแแก แฉแแแแแแ แแฎแแ แแแญแแ แแแแ.
แแคแแแแ แแแแ แแขแแ แฐแแแแก แแแแแ แขแแแแแฃแแ แจแแฅแแแ
แแแแแแ แแแฃแ แฅแกแแแจแ OpenShift แแแแกแขแแ แแก แแแแแแแแแแก แจแแแแฎแแแแแจแ, แกแแแแแแแช แแแขแแ แแแขแแ แฌแแแแแ แจแแแฆแฃแแฃแแแ แแ แแ แแ แกแแแแแก, OperatorHub แ แแแกแขแ แแกแแแแก โแกแแ แแแกโ แจแแฅแแแ แแแแแ แขแแแแแฃแแแ. แแฎแแ แแก แจแแแซแแแแ แแแแแแแแก แแฎแแแแ แกแแแ แแฃแแแแ.
แฒแแขแแ แแแ:
แแแฅแขแแ แแฃแฉแแแแ, แแฃแ แ แกแแแแแแฃแแแแ
แฌแงแแ แ: www.habr.com