- OpenShift 教程
- OpenShift - 主页
- OpenShift - 概述
- OpenShift - 类型
- OpenShift - 架构
- OpenShift - 环境设置
- OpenShift - 基本概念
- OpenShift - 入门
- OpenShift - 构建自动化
- OpenShift-CLI
- OpenShift - CLI 操作
- OpenShift - 集群
- OpenShift - 应用程序扩展
- OpenShift - 管理
- OpenShift - Docker 和 Kubernetes
- OpenShift - 安全
- OpenShift 有用资源
- OpenShift - 快速指南
- OpenShift - 有用的资源
- OpenShift - 讨论
OpenShift - 快速指南
OpenShift - 概述
OpenShift 是由红帽托管的云开发平台即服务 (PaaS)。它是一个基于云的开源用户友好平台，用于创建、测试和运行应用程序，并最终将它们部署在云上。
OpenShift 能够管理用不同语言编写的应用程序，例如 Node.js、Ruby、Python、Perl 和 Java。OpenShift 的关键特性之一是它是可扩展的，这有助于用户支持用其他语言编写的应用程序。
OpenShift 将各种虚拟化概念作为其抽象层。OpenShift 背后的基本概念基于虚拟化。
虚拟化
一般来说，虚拟化可以定义为虚拟系统的创建，而不是从系统、存储或操作系统开始的任何事物的物理或实际版本。虚拟化的主要目标是使 IT 基础设施更具可扩展性和可靠性。虚拟化的概念已经存在了几十年，随着当今IT行业的发展，它可以应用于从系统级、硬件级到服务器级虚拟化的广泛层面。
怎么运行的
它可以被描述为一种技术，其中任何应用程序或操作系统都从其实际的物理层中抽象出来。虚拟化技术的一个关键用途是服务器虚拟化，它使用一种称为虚拟机管理程序的软件从底层硬件中抽象出该层。在虚拟化上运行的操作系统的性能与在物理硬件上运行时的性能一样好。然而，虚拟化的概念很流行，因为大多数系统和应用程序运行不需要使用底层硬件。
物理架构与虚拟架构
虚拟化的类型
应用程序虚拟化- 在这种方法中，应用程序是从底层操作系统中抽象出来的。这种方法非常有用，应用程序可以独立运行，而不依赖于底层的操作系统。
桌面虚拟化- 此方法用于减少工作站负载，其中人们可以使用办公桌上的瘦客户端远程访问桌面。在这种方法中，桌面主要在数据中心中运行。一个典型的例子是大多数组织中使用的虚拟桌面映像 (VDI)。
数据虚拟化- 它是一种抽象和摆脱传统数据和数据管理方法的方法。
服务器虚拟化- 在这种方法中，与服务器相关的资源被虚拟化，包括物理服务器、进程和操作系统。支持这种抽象的软件通常称为虚拟机管理程序。
存储虚拟化- 是将多个存储设备汇集到单个存储设备中并通过单个中央控制台进行管理的过程。
网络虚拟化- 这是一种通过分割可用带宽和通道来组合所有可用网络资源的方法，每个可用带宽和通道都是相互独立的。
开放式班次
OpenShift 是一个支持云的应用程序平台即服务 (PaaS)。它是一项开源技术，可帮助组织将其传统应用程序基础架构和平台从物理、虚拟介质迁移到云。
OpenShift支持非常多的应用程序，可以在OpenShift云平台上轻松开发和部署这些应用程序。OpenShift 基本上为开发者和用户支持三种平台。
基础设施即服务 (IaaS)
在这种格式中，服务提供商提供具有一些预定义虚拟硬件配置的硬件级虚拟机。这个领域有很多竞争对手，包括 AWS、谷歌云、Rackspace 等等。
经过漫长的设置和投资过程后，拥有 IaaS 的主要缺点是，人们仍然负责安装和维护操作系统和服务器包、管理基础设施网络以及处理基本系统管理。
软件即服务 (SaaS)
有了SaaS，人们就不用担心底层基础设施了。它就像即插即用一样简单，用户只需注册服务并开始使用即可。这种设置的主要缺点是，只能执行服务提供商允许的最少量的定制。SaaS 最常见的示例之一是 Gmail，用户只需登录并开始使用它。用户还可以对其帐户进行一些细微的修改。然而，从开发人员的角度来看，它并不是很有用。
平台即服务 (PaaS)
它可以被认为是SaaS和IaaS之间的中间层。PaaS 评估的主要目标是开发人员，其中可以通过一些命令启动开发环境。这些环境的设计方式使得它们可以满足所有开发需求，只需拥有带有数据库的 Web 应用程序服务器即可。为此，您只需要一个命令，服务提供商就会为您完成这些工作。
为什么使用 OpenShift？
OpenShift 为企业单位提供了一个通用平台，可以在云上托管其应用程序，而无需担心底层操作系统。这使得在云上使用、开发和部署应用程序变得非常容易。主要功能之一是，它为各种开发和测试提供托管硬件和网络资源。借助 OpenShift，PaaS 开发人员可以自由地按照规范设计所需的环境。
OpenShift 在服务计划方面提供不同类型的服务级别协议。
免费- 此计划的有效期为三年，每次 1GB 空间。
铜牌- 此计划包括 3 年，可扩展至 16 年，每年 1GB 空间。
Sliver - 这是青铜的 16 年计划，但是具有 6GB 的存储容量，无需额外费用。
除了上述功能之外，OpenShift 还提供称为 OpenShift Enterprise 的本地版本。在 OpenShift 中，开发人员可以利用设计可扩展和不可扩展的应用程序，并且这些设计是使用 HAproxy 服务器实现的。
特征
OpenShift 支持多种功能。其中很少有 -
- 多语言支持
- 多数据库支持
- 可扩展墨盒系统
- 源代码版本管理
- 一键部署
- 多环境支持
- 标准化开发人员工作流程
- 依赖和构建管理
- 自动应用程序扩展
- 响应式 Web 控制台
- 丰富的命令行工具集
- 远程 SSH 登录应用程序
- 休息 API 支持
- 自助服务按需应用程序堆栈
- 内置数据库服务
- 持续集成和发布管理
- IDE集成
- 应用程序的远程调试
OpenShift - 类型
OpenShift 的诞生源于其名为 OpenShift V2 的基础，它主要基于年和盒的概念，其中每个组件从机器创建到应用程序部署，从构建到部署应用程序都有其规格。
盒- 它们是构建新应用程序的焦点，从运行它们的环境所需的应用程序类型以及本节中满足的所有依赖项开始。
年- 它可以被定义为具有一定资源、内存和CPU规格的熊金属机器或服务器。它们被认为是运行应用程序的基本单元。
应用程序- 这些只是指将在 OpenShift 环境中部署和运行的应用程序或任何集成应用程序。
当我们深入本节时，我们将讨论 OpenShift 的不同格式和产品。早期，OpenShift 有三个主要版本。
OpenShift Origin - 这是 OpenShift 的社区添加或开源版本。其他两个版本也被称为上游项目。
OpenShift Online - 它是托管在 AWS 上的公共 PaaS 即服务。
OpenShift Enterprise - 是具有 ISV 和供应商许可证的 OpenShift 强化版本。
OpenShift 在线
OpenShift Online 是 OpenShift 社区的一项产品，使用它可以在公共云上快速构建、部署和扩展容器化应用程序。它是红帽的公共云应用程序开发和托管平台，可实现应用程序的自动配置、管理和扩展，帮助开发人员专注于编写应用程序逻辑。
在 Red Hat OpenShift Online 上设置帐户
步骤 1 - 转到浏览器并访问网站https://manage.openshift.com/
步骤 2 - 如果您有 Red Hat 帐户，请使用以下 URL 使用 Red Hat 登录 ID 和密码登录 OpenShift 帐户。https://developers.redhat.com
步骤 3 - 如果您没有 Red Hat 帐户登录，请使用以下链接注册 OpenShift 在线服务。
登录后，您将看到以下页面。
完成所有准备工作后，红帽将显示一些基本帐户详细信息，如以下屏幕截图所示。
最后，当您登录时，您将看到以下页面。
OpenShift 容器平台
OpenShift容器平台是一个企业平台，可帮助开发和IT运营团队等多个团队构建和部署容器化基础设施。OpenShift构建的所有容器都使用非常可靠的Docker容器化技术，可以部署在公共托管云平台的任何数据中心上。
OpenShift 容器平台的正式名称为 OpenShift Enterprises。它是一个红帽本地私有平台即服务，建立在由 Docker 提供支持的应用程序容器的核心概念之上，其中编排和管理由 Kubernetes 进行管理。
换句话说，OpenShift 将 Docker 和 Kubernetes 结合到了企业级。它是一个容器平台软件，供企业单位在自己选择的基础设施中部署和管理申请人。例如，在 AWS 实例上托管 OpenShift 实例。
OpenShift 容器平台有两个软件包级别。
OpenShift Container Local - 适用于那些希望在本地计算机上部署和测试应用程序的开发人员。该包主要供开发团队用于开发和测试应用程序。
OpenShift Container Lab - 旨在对应用程序进行扩展评估，从开发到部署到预生产环境。
OpenShift 专用
这是 OpenShift 产品组合中添加的另一项产品，客户可以选择在他们选择的任何公共云上托管容器化平台。这让最终用户真正感受到多云产品，他们可以在任何满足其需求的云上使用 OpenShift。
这是红帽的最新产品之一，最终用户可以使用 OpenShift 在云托管的 OpenShift 上构建测试部署并运行其应用程序。
OpenShift 专用版的特点
OpenShift专门在公有云上提供定制化解决方案应用平台，它继承自OpenShift 3技术。
可扩展和开放- 这是基于 Docker 的开放概念构建的，并部署在云上，因此它可以根据需要进行扩展。
可移植性- 由于它是使用 Docker 构建的，因此在 Docker 上运行的应用程序可以轻松地从一个地方运送到支持 Docker 的另一个地方。
编排- 在 OpenShift 3 中，使用 Kubernetes 支持容器编排和集群管理的关键功能之一，Kubernetes 是随 OpenShift 版本 3 一起提供的。
自动化- 此版本的 OpenShift 具有源代码管理、构建自动化和部署自动化功能，这使得它作为平台即服务提供商在市场上非常受欢迎。
OpenShift 的竞争对手
Google App Engine - 这是 Google 用于开发和托管网络应用程序的免费平台。Google 的应用程序引擎提供快速开发和部署平台。
Microsoft Azure - Azure 云由 Microsoft 在其数据中心托管。
Amazon Elastic Cloud Compute - 它们是 Amazon 提供的内置服务，有助于在云上开发和托管可扩展的 Web 应用程序。
Cloud Foundry - 是一个适用于 Java、Ruby、Python 和 Node.js 应用程序的开源 PaaS 平台。
CloudStack - Apache 的 CloudStack 是 Citrix 开发的一个项目，旨在成为 OpenShift 和 OpenStack 的直接竞争对手。
OpenStack - 红帽为云计算提供的另一种云技术。
Kubernetes - 它是一种直接编排和集群管理技术，旨在管理 Docker 容器。
OpenShift - 架构
OpenShift 是一个分层系统，其中每一层都使用 Kubernetes 和 Docker 集群与另一层紧密绑定。OpenShift 的架构设计为可以支持和管理 Docker 容器，这些容器使用 Kubernetes 托管在所有层之上。与早期版本的 OpenShift V2 不同，新版本的 OpenShift V3 支持容器化基础设施。在此模型中，Docker 帮助创建基于 Linux 的轻量级容器，而 Kubernetes 支持在多个主机上编排和管理容器的任务。
OpenShift 的组件
OpenShift 架构的关键组件之一是管理 Kubernetes 中的容器化基础设施。Kubernetes 负责基础设施的部署和管理。在任何 Kubernetes 集群中，我们都可以有多个主节点和多个节点，这确保了设置中没有故障点。
Kubernetes主机组件
Etcd - 它存储配置信息，可供集群中的每个节点使用。它是一个高可用性键值存储，可以分布在多个节点之间。它只能由 Kubernetes API 服务器访问，因为它可能包含敏感信息。它是一个所有人都可以访问的分布式键值存储。
API 服务器- Kubernetes 是一个 API 服务器，它使用 API 提供集群上的所有操作。API 服务器实现了一个接口，这意味着不同的工具和库可以轻松地与其通信。kubeconfig 是一个包含可用于通信的服务器端工具的包。它公开了 Kubernetes API”。
控制器管理器- 该组件负责调节集群状态并执行任务的大多数收集器。它可以被认为是一个以非终止循环运行的守护进程，负责收集信息并将其发送到 API 服务器。它致力于获取集群的共享状态，然后进行更改以使服务器的当前状态达到所需的状态。关键控制器是复制控制器、端点控制器、命名空间控制器和服务帐户控制器。控制器管理器运行不同类型的控制器来处理节点、端点等。
Scheduler - 它是 Kubernetes master 的关键组件。它是 master 中的一个服务，负责分配工作负载。它负责跟踪集群节点上工作负载的利用率，然后将工作负载放置在可用资源上并接受工作负载。换句话说，这是负责将 pod 分配给可用节点的机制。调度程序负责工作负载利用率并将 Pod 分配给新节点。
Kubernetes 节点组件
以下是 Node 服务器的关键组件，它们是与 Kubernetes master 通信所必需的。
Docker - 每个节点的首要要求是 Docker，它有助于在相对隔离但轻量级的操作环境中运行封装的应用程序容器。
Kubelet 服务- 这是每个节点中的一个小型服务，负责在控制平面服务之间转发信息。它与 etcd 存储交互以读取配置详细信息和 Wright 值。它与主组件通信以接收命令并工作。然后，kubelet 进程承担维护工作状态和节点服务器的责任。它管理网络规则、端口转发等。
Kubernetes 代理服务- 这是一个在每个节点上运行的代理服务，有助于使服务可供外部主机使用。它有助于将请求转发到正确的容器。Kubernetes Proxy Service 能够进行原始负载均衡。它确保网络环境是可预测和可访问的，但同时它也是隔离的。它管理节点上的 pod、卷、秘密、创建新容器健康检查等。
集成 OpenShift 容器注册表
OpenShift容器注册表是Red Hat内置的存储单元，用于存储Docker镜像。借助最新的 OpenShift 集成版本，它提供了一个用户界面来查看 OpenShift 内部存储中的图像。这些注册表能够保存带有指定标签的镜像，这些镜像随后用于构建容器。
常用术语
图像- Kubernetes（Docker）图像是容器化基础设施的关键构建块。目前，Kubernetes 仅支持 Docker 镜像。Pod 中的每个容器都在其中运行其 Docker 映像。配置 pod 时，配置文件中的 image 属性与 Docker 命令的语法相同。
项目- 它们可以定义为 OpenShift V2 早期版本中存在的域的重命名版本。
容器- 它们是在将映像部署到 Kubernetes 集群节点上之后创建的容器。
节点- 节点是 Kubernetes 集群中的工作机器，也称为 master 的 minion。它们是工作单元，可以是物理、虚拟机或云实例。
Pod - Pod 是 Kubernetes 集群节点内容器及其存储的集合。可以创建一个内部包含多个容器的 Pod。例如，将数据库容器和 Web 服务器容器保留在 pod 内。
OpenShift - 环境设置
在本章中，我们将了解OpenShift的环境设置。
系统要求
为了设置企业 OpenShift，需要拥有一个有效的 Red Hat 帐户。由于 OpenShift 工作在 Kubernetes 主节点和节点架构上，因此我们需要将它们设置在不同的机器上，其中一台机器作为主节点，其他机器在节点上工作。为了设置两者，有最低系统要求。
主机配置
以下是主机配置的最低系统要求。
托管在物理、虚拟或任何云环境上的基础计算机。
至少 Linux 7 具有该实例上所需的软件包。
2个CPU核心。
至少 8 GB 内存。
30 GB 内部硬盘存储器。
节点机配置
- 为主机指定的物理或虚拟基础映像。
- 机器上至少有 Linux 7。
- 安装的 Docker 版本不低于 1.6。
- 1个CPU核心。
- 8 GB 内存。
- 15 GB 硬盘用于托管图像，15 GB 硬盘用于存储图像。
OpenShift 设置分步指南
在下面的描述中，我们将建立 OpenShift 实验室环境，稍后可以将其扩展到更大的集群。由于 OpenShift 需要设置主节点和节点，因此我们需要至少两台托管在云、物理机或虚拟机上的计算机。
步骤 1 - 首先在两台机器上安装 Linux，其中 Linux 7 应该是最低版本。如果拥有有效的 Red Hat 订阅，则可以使用以下命令来完成此操作。
# subscription-manager repos --disable = "*"
# subscription-manager repos --enable = "rhel-7-server-rpms"
# subscription-manager repos --enable = "rhel-7-server-extras-rpms"
# subscription-manager repos --enable = "rhel-7-server-optional-rpms"
# subscription-manager repos --enable = "rhel-7-server-ose-3.0-rpms"
# yum install wget git net-tools bind-utils iptables-services bridge-utils
# yum install wget git net-tools bind-utils iptables-services bridge-utils
# yum install python-virtualenv
# yum install gcc
# yum install httpd-tools
# yum install docker
# yum update
一旦我们在两台机器上安装了所有上述基础包，下一步就是在各自的机器上设置 Docker。
步骤 2 - 配置 Docker，使其仅允许本地网络上的不安全通信。为此，请编辑 /etc/sysconfig 中的 Docker 文件。如果该文件不存在，则您需要手动创建它。
# vi /etc/sysconfig/docker OPTIONS = --selinux-enabled --insecure-registry 192.168.122.0/24
在主机器上配置 Docker 后，我们需要在两台机器之间建立无密码通信。为此，我们将使用公钥和私钥身份验证。
步骤 3 - 在主计算机上生成密钥，然后将 id_rsa.pub 密钥复制到节点计算机的授权密钥文件中，这可以使用以下命令来完成。
# ssh-keygen
# ssh-copy-id -i .ssh/id_rsa.pub root@ose3-node.test.com
完成上述所有设置后，下一步是在主计算机上设置 OpenShift 版本 3。
步骤 4 - 从主机上运行以下curl 命令。
# sh <(curl -s https://install.openshift.com/ose)
上述命令将为 OSV3 进行设置。下一步是在计算机上配置 OpenShift V3。
如果无法直接从 Internet 下载，则可以从https://install.openshift.com/portable/oo-install-ose.tgz下载tar 包，安装程序可以在本地主计算机上运行。
一旦我们准备好设置，我们就需要开始在机器上实际配置 OSV3。此设置非常适合测试实际生产环境，我们有 LDAP 和其他东西。
步骤 5 - 在主机上，配置 /etc/openshift/master/master-config.yaml 下的以下代码
# vi /etc/openshift/master/master-config.yaml identityProviders: - name: my_htpasswd_provider challenge: true login: true provider: apiVersion: v1 kind: HTPasswdPasswordIdentityProvider file: /root/users.htpasswd routingConfig: subdomain: testing.com
接下来，创建一个用于默认管理的标准用户。
# htpasswd -c /root/users.htpasswd admin
步骤 6 - 由于 OpenShift 使用 Docker 注册表来配置映像，因此我们需要配置 Docker 注册表。这用于在构建后创建和存储 Docker 映像。
使用以下命令在 OpenShift 节点计算机上创建目录。
# mkdir /images
接下来，使用默认管理凭据登录主机，该凭据是在设置注册表时创建的。
# oc login Username: system:admin
切换到默认创建的项目。
# oc project default
第 7 步- 创建 Docker 注册表。
#echo '{"kind":"ServiceAccount","apiVersion":"v1","metadata":{"name":"registry"}}' | oc create -f -
编辑用户权限。
#oc edit scc privileged users: - system:serviceaccount:openshift-infra:build-controller - system:serviceaccount:default:registry
创建和编辑图像注册表。
#oadm registry --service-account = registry --
config = /etc/openshift/master/admin.kubeconfig --
credentials = /etc/openshift/master/openshift-registry.kubeconfig --
images = 'registry.access.redhat.com/openshift3/ose-${component}:${version}' --
mount-host = /images
步骤 8 - 创建默认路由。
默认情况下，OpenShift 使用 OpenVswitch 作为软件网络。使用以下命令创建默认路由。这用于负载平衡和代理路由。路由器类似于Docker注册表，也是在注册表中运行。
# echo '{"kind":"ServiceAccount","apiVersion":"v1","metadata":{"name":"router"}}' | oc create -f -
接下来，编辑用户的权限。
#oc edit scc privileged
users:
- system:serviceaccount:openshift-infra:build-controller
- system:serviceaccount:default:registry
- system:serviceaccount:default:router
#oadm router router-1 --replicas = 1 --
credentials = '/etc/openshift/master/openshift-router.kubeconfig' --
images = 'registry.access.redhat.com/openshift3/ose-${component}:${version}'
步骤 9 - 配置 DNS。
为了处理 URL 请求，OpenShift 需要一个有效的 DNS 环境。创建通配符需要此 DNS 配置，创建指向路由器的 DNS 通配符需要此配置。
# yum install bind-utils bind
# systemctl start named
# systemctl enable named
vi /etc/named.conf
options {listen-on port 53 { 10.123.55.111; };
forwarders {
10.38.55.13;
;
};
zone "lab.com" IN {
type master;
file "/var/named/dynamic/test.com.zone";
allow-update { none; };
};
步骤 10 - 最后一步是在 OpenShift V3 主计算机上设置 github 服务器，这是可选的。使用以下命令序列可以轻松完成此操作。
#yum install curl openssh-server
#systemctl enable sshd
# systemctl start sshd
# firewall-cmd --permanent --add-service = http
# systemctl reload firewalld
#curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-
#yum install gitlab-ce
# gitlab-ctl reconfigure
完成上述设置后，您可以通过测试进行验证并部署应用程序，我们将在后续章节中详细介绍。
OpenShift - 基本概念
在开始实际设置和部署应用程序之前，我们需要了解 OpenShift V3 中使用的一些基本术语和概念。
容器和镜像
图片
这些是 OpenShift 的基本构建块，由 Docker 镜像组成。在 OpenShift 上的每个 Pod 中，集群都有自己的镜像在其中运行。当我们配置 Pod 时，我们有一个将从注册表中池化的字段。此配置文件将拉取映像并将其部署在集群节点上。
apiVersion: v1
kind: pod
metadata:
name: Tesing_for_Image_pull -----------> Name of Pod
spec:
containers:
- name: neo4j-server ------------------------> Name of the image
image: <Name of the Docker image>----------> Image to be pulled
imagePullPolicy: Always ------------->Image pull policy
command: [“echo”, “SUCCESS”] -------------------> Massage after image pull
为了从中提取并创建图像，请运行以下命令。OC是登录后与OpenShift环境通信的客户端。
$ oc create –f Tesing_for_Image_pull
容器
当 Docker 镜像部署到 OpenShift 集群上时，就会创建该文件。在定义任何配置时，我们在配置文件中定义容器部分。一个容器内可以运行多个镜像，集群节点上运行的所有容器均由 OpenShift Kubernetes 管理。
spec: containers: - name: py ------------------------> Name of the container image: python----------> Image going to get deployed on container command: [“python”, “SUCCESS”] restartPocliy: Never --------> Restart policy of container
以下是定义在其中运行多个映像的容器的规范。
apiVersion: v1
kind: Pod
metadata:
name: Tomcat
spec:
containers:
- name: Tomcat
image: tomcat: 8.0
ports:
- containerPort: 7500
imagePullPolicy: Always
-name: Database
Image: mongoDB
Ports:
- containerPort: 7501
imagePullPolicy: Always
在上面的配置中，我们定义了一个多容器 Pod，里面有 Tomcat 和 MongoDB 两个镜像。
Pod 和服务
豆荚
Pod 可以定义为 OpenShift (Kubernetes) 集群节点内容器及其存储的集合。一般来说，我们有两种类型的 Pod，从单容器 Pod 到多容器 Pod。
单容器 Pod - 这些可以使用 OC 命令或基本配置 yml 文件轻松创建。
$ oc run <name of pod> --image = <name of the image from registry>
使用简单的 yaml 文件创建它，如下所示。
apiVersion: v1
kind: Pod
metadata:
name: apache
spec:
containers:
- name: apache
image: apache: 8.0
ports:
- containerPort: 7500
imagePullPolicy: Always
创建上述文件后，它将使用以下命令生成一个 pod。
$ oc create –f apache.yml
多容器 Pod - 多容器 Pod 是指其中运行多个容器的 Pod。它们是使用 yaml 文件创建的，如下所示。
apiVersion: v1
kind: Pod
metadata:
name: Tomcat
spec:
containers:
- name: Tomcat
image: tomcat: 8.0
ports:
- containerPort: 7500
imagePullPolicy: Always
-name: Database
Image: mongoDB
Ports:
- containerPort: 7501
imagePullPolicy: Always
创建完这些文件后，我们就可以简单地使用与上面相同的方法来创建容器。
服务- 由于我们有一组在 pod 内运行的容器，因此我们有一个可以定义为 pod 逻辑集的服务。它是 Pod 之上的一个抽象层，提供单个 IP 和 DNS 名称，通过该名称可以访问 Pod。服务有助于管理负载平衡配置并非常轻松地扩展 Pod。在 OpenShift 中，服务是一个 REST 对象，其神化可以发布到 OpenShift master 上的 apiService 以创建新实例。
apiVersion: v1
kind: Service
metadata:
name: Tutorial_point_service
spec:
ports:
- port: 8080
targetPort: 31999
构建和流式传输
构建
在 OpenShift 中，构建是将镜像转换为容器的过程。是将源代码转换为图像的处理。此构建过程按照将源代码构建为映像的预定义策略进行。
构建过程处理多种策略和来源。
制定策略
源到图像- 这基本上是一个工具，有助于构建可复制的图像。这些镜像始终处于准备阶段，可以使用 Docker run 命令运行。
Docker Build - 这是通过运行简单的 Docker 构建命令使用 Docker 文件构建图像的过程。
自定义构建- 这些是用于创建基本 Docker 映像的构建。
构建源
Git - 当 git 存储库用于构建图像时使用此源。Dockerfile 是可选的。源代码中的配置如下所示。
source: type: "Git" git: uri: "https://github.com/vipin/testing.git" ref: "master" contextDir: "app/dir" dockerfile: "FROM openshift/ruby-22-centos7\nUSER example"
Dockerfile - Dockerfile 用作配置文件中的输入。
source: type: "Dockerfile" dockerfile: "FROM ubuntu: latest RUN yum install -y httpd"
图像流- 图像流是在拉取图像后创建的。图像流的优点是它会查找新版本图像的更新。这用于比较由标签标识的任意数量的 Docker 格式的容器映像。
创建新图像时，图像流可以自动执行操作。所有构建和部署都可以监视图像操作并相应地执行操作。以下是我们如何定义构建流。
apiVersion: v1
kind: ImageStream
metadata:
annotations:
openshift.io/generated-by: OpenShiftNewApp
generation: 1
labels:
app: ruby-sample-build
selflink: /oapi/v1/namespaces/test/imagestreams/origin-ruby-sample
uid: ee2b9405-c68c-11e5-8a99-525400f25e34
spec: {}
status:
dockerImageRepository: 172.30.56.218:5000/test/origin-ruby-sample
tags:
- items:
- created: 2016-01-29T13:40:11Z
dockerImageReference: 172.30.56.218:5000/test/origin-apache-sample
generation: 1
image: vklnld908.int.clsa.com/vipin/test
tag: latest
路线和模板
路线
在 OpenShift 中，路由是一种通过创建和配置外部可访问的主机名来向外部世界公开服务的方法。路由和端点用于将服务公开给外部世界，用户可以从外部世界使用名称连接 (DNS) 来访问定义的应用程序。
在 OpenShift 中，路由是使用 OpenShift 管理员在集群上部署的路由器创建的。路由器用于将 HTTP (80) 和 https (443) 端口绑定到外部应用程序。
以下是路由支持的不同类型的协议 -
- HTTP协议
- HTTPS
- TSL 和网络套接字
配置服务时，选择器用于配置服务并查找使用该服务的端点。以下是我们如何使用适当的协议创建服务和该服务的路由的示例。
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {"name": "Openshift-Rservice"},
"spec": {
"selector": {"name":"RService-openshift"},
"ports": [
{
"protocol": "TCP",
"port": 8888,
"targetPort": 8080
}
]
}
}
接下来，运行以下命令并创建服务。
$ oc create -f ~/training/content/Openshift-Rservice.json
这是服务创建后的样子。
$ oc describe service Openshift-Rservice Name: Openshift-Rservice Labels: <none> Selector: name = RService-openshift Type: ClusterIP IP: 172.30.42.80 Port: <unnamed> 8080/TCP Endpoints: <none> Session Affinity: None No events.
使用以下代码创建服务路由。
{
"kind": "Route",
"apiVersion": "v1",
"metadata": {"name": "Openshift-service-route"},
"spec": {
"host": "hello-openshift.cloudapps.example.com",
"to": {
"kind": "Service",
"name": "OpenShift-route-service"
},
"tls": {"termination": "edge"}
}
}
当使用OC命令创建路由时，会创建一个新的路由资源实例。
模板
模板在 OpenShift 中被定义为标准对象，可以多次使用。它使用用于创建多个对象的占位符列表进行参数化。这可以用来创建任何东西，从 Pod 到网络，用户有权创建这些内容。如果将图像中 CLI 或 GUI 界面的模板上传到项目目录，则可以创建对象列表。
apiVersion: v1
kind: Template
metadata:
name: <Name of template>
annotations:
description: <Description of Tag>
iconClass: "icon-redis"
tags: <Tages of image>
objects:
- apiVersion: v1
kind: Pod
metadata:
name: <Object Specification>
spec:
containers:
image: <Image Name>
name: master
ports:
- containerPort: <Container port number>
protocol: <Protocol>
labels:
redis: <Communication Type>
认证与授权
验证
在 OpenShift 中，在配置 master 和客户端结构时，master 提供了 OAuth 服务器的内置功能。OAuth 服务器用于生成令牌，用于对 API 进行身份验证。由于 OAuth 作为 master 的默认设置，因此我们默认使用“允许所有”身份提供程序。存在不同的身份提供程序，可以在/etc/openshift/master/master-config.yaml进行配置。
OAuth 中存在不同类型的身份提供者。
- 允许全部
- 全部拒绝
- HT密码
- LDAP
- 基本认证
允许全部
apiVersion: v1
kind: Pod
metadata:
name: redis-master
spec:
containers:
image: dockerfile/redis
name: master
ports:
- containerPort: 6379
protocol: TCP
oauthConfig:
identityProviders:
- name: my_allow_provider
challenge: true
login: true
provider:
apiVersion: v1
kind: AllowAllPasswordIdentityProvider
全部拒绝
apiVersion: v1
kind: Pod
metadata:
name: redis-master
spec:
containers:
image: dockerfile/redis
name: master
ports:
- containerPort: 6379
protocol: TCP
oauthConfig:
identityProviders:
- name: my_allow_provider
challenge: true
login: true
provider:
apiVersion: v1
kind: DenyAllPasswordIdentityProvider
HT密码
为了使用HTPasswd，我们需要首先在主机上设置Httpd-tools，然后按照与其他机器相同的方式进行配置。
identityProviders:
- name: my_htpasswd_provider
challenge: true
login: true
provider:
apiVersion: v1
kind: HTPasswdPasswordIdentityProvider
授权
授权是OpenShift master的一项功能，用于验证用户的身份。这意味着它会检查尝试执行操作的用户，以查看该用户是否有权在给定项目上执行该操作。这有助于管理员控制对项目的访问。
授权策略使用控制 -
- 规则
- 角色
- 绑定
授权评估是使用 -
- 身份
- 行动
- 绑定
使用政策 -
- 集群政策
- 当地政策
OpenShift - 入门
OpenShift 包含两种类型的中间件，用于通过 GUI 或 CLI 创建和部署应用程序。在本章中，我们将使用 CLI 创建一个新应用程序。我们将使用 OC 客户端与 OpenShift 环境进行通信。
创建新应用程序
在 OpenShift 中，可以通过三种方法创建新应用程序。
- 来自源代码
- 从图像
- 从模板
来自源代码
当我们尝试从源代码创建应用程序时，OpenShift 会查找存储库中应存在的 Docker 文件，该文件定义了应用程序构建流程。我们将使用 oc new-app 来创建一个应用程序。
使用存储库时要记住的第一件事是，它应该指向存储库中的源，OpenShift 将从中提取代码并构建它。
如果存储库克隆在安装了 OC 客户端的 Docker 机器上并且用户位于同一目录中，则可以使用以下命令创建它。
$ oc new-app . <Hear. Denotes current working directory>
以下是尝试从远程存储库为特定分支构建的示例。
$ oc new-app https://github.com/openshift/Testing-deployment.git#test1
这里，test1 是我们尝试在 OpenShift 中创建新应用程序的分支。
当在存储库中指定 Docker 文件时，我们需要定义构建策略，如下所示。
$ oc new-app OpenShift/OpenShift-test~https://github.com/openshift/Testingdeployment.git
从图像
使用镜像构建应用程序时，镜像存在于本地 Docker 服务器、内部托管的 Docker 存储库或 Docker hub 中。用户需要确保的唯一一件事是，他可以毫无问题地从中心提取图像。
OpenShift 能够确定所使用的源，无论是 Docker 映像还是源流。然而，如果用户希望他可以明确定义它是图像流还是 Docker 图像。
$ oc new-app - - docker-image tomcat
使用图像流 -
$ oc new-app tomcat:v1
从模板
模板可用于创建新应用程序。它可以是现有的模板或创建新的模板。
以下 yaml 文件基本上是可用于部署的模板。
apiVersion: v1
kind: Template
metadata:
name: <Name of template>
annotations:
description: <Description of Tag>
iconClass: "icon-redis"
tags: <Tages of image>
objects:
- apiVersion: v1
kind: Pod
metadata:
name: <Object Specification>
spec:
containers:
image: <Image Name>
name: master
ports:
- containerPort: <Container port number>
protocol: <Protocol>
labels:
redis: <Communication Type>
开发和部署 Web 应用程序
在 OpenShift 中开发新应用程序
为了在 OpenShift 中创建新的应用程序，我们必须编写新的应用程序代码并使用 OpenShift OC 构建命令进行构建。正如所讨论的，我们有多种创建新图像的方法。在这里，我们将使用模板来构建应用程序。当使用 oc new-app 命令运行时，此模板将构建一个新应用程序。
以下模板将创建 - 两个前端应用程序和一个数据库。除此之外，它将创建两个新服务，这些应用程序将部署到 OpenShift 集群。在构建和部署应用程序时，最初我们需要在 OpenShift 中创建一个命名空间，并在该命名空间下部署应用程序。
创建一个新的命名空间
$ oc new-project openshift-test --display-name = "OpenShift 3 Sample" -- description = "This is an example project to demonstrate OpenShift v3"
模板
{
"kind": "Template",
"apiVersion": "v1",
"metadata": {
"name": "openshift-helloworld-sample",
"creationTimestamp": null,
"annotations": {
"description": "This example shows how to create a simple openshift
application in openshift origin v3",
"iconClass": "icon-openshift",
"tags": "instant-app,openshift,mysql"
}
}
},
对象定义
模板中的秘密定义
"objects": [
{
"kind": "Secret",
"apiVersion": "v1",
"metadata": {"name": "dbsecret"},
"stringData" : {
"mysql-user" : "${MYSQL_USER}",
"mysql-password" : "${MYSQL_PASSWORD}"
}
},
模板中的服务定义
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "frontend",
"creationTimestamp": null
},
"spec": {
"ports": [
{
"name": "web",
"protocol": "TCP",
"port": 5432,
"targetPort": 8080,
"nodePort": 0
}
],
"selector": {"name": "frontend"},
"type": "ClusterIP",
"sessionAffinity": "None"
},
"status": {
"loadBalancer": {}
}
},
模板中的路由定义
{
"kind": "Route",
"apiVersion": "v1",
"metadata": {
"name": "route-edge",
"creationTimestamp": null,
"annotations": {
"template.openshift.io/expose-uri": "http://{.spec.host}{.spec.path}"
}
},
"spec": {
"host": "www.example.com",
"to": {
"kind": "Service",
"name": "frontend"
},
"tls": {
"termination": "edge"
}
},
"status": {}
},
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "origin-openshift-sample",
"creationTimestamp": null
},
"spec": {},
"status": {
"dockerImageRepository": ""
}
},
{
"kind": "ImageStream",
"apiVersion": "v1",
"metadata": {
"name": "openshift-22-ubuntu7",
"creationTimestamp": null
},
"spec": {
"dockerImageRepository": "ubuntu/openshift-22-ubuntu7"
},
"status": {
"dockerImageRepository": ""
}
},
在模板中构建配置定义
{
"kind": "BuildConfig",
"apiVersion": "v1",
"metadata": {
"name": "openshift-sample-build",
"creationTimestamp": null,
"labels": {name": "openshift-sample-build"}
},
"spec": {
"triggers": [
{ "type": "GitHub",
"github": {
"secret": "secret101" }
},
{
"type": "Generic",
"generic": {
"secret": "secret101",
"allowEnv": true }
},
{
"type": "ImageChange",
"imageChange": {}
},
{ "type": "ConfigChange”}
],
"source": {
"type": "Git",
"git": {
"uri": https://github.com/openshift/openshift-hello-world.git }
},
"strategy": {
"type": "Docker",
"dockerStrategy": {
"from": {
"kind": "ImageStreamTag",
"name": "openshift-22-ubuntu7:latest”
},
"env": [
{
"name": "EXAMPLE",
"value": "sample-app"
}
]
}
},
"output": {
"to": {
"kind": "ImageStreamTag",
"name": "origin-openshift-sample:latest"
}
},
"postCommit": {
"args": ["bundle", "exec", "rake", "test"]
},
"status": {
"lastVersion": 0
}
}
},
模板中的部署配置
"status": {
"lastVersion": 0
}
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "frontend",
"creationTimestamp": null
}
},
"spec": {
"strategy": {
"type": "Rolling",
"rollingParams": {
"updatePeriodSeconds": 1,
"intervalSeconds": 1,
"timeoutSeconds": 120,
"pre": {
"failurePolicy": "Abort",
"execNewPod": {
"command": [
"/bin/true"
],
"env": [
{
"name": "CUSTOM_VAR1",
"value": "custom_value1"
}
]
}
}
}
}
}
"triggers": [
{
"type": "ImageChange",
"imageChangeParams": {
"automatic": true,
"containerNames": [
"openshift-helloworld"
],
"from": {
"kind": "ImageStreamTag",
"name": "origin-openshift-sample:latest"
}
}
},
{
"type": "ConfigChange"
}
],
"replicas": 2,
"selector": {
"name": "frontend"
},
"template": {
"metadata": {
"creationTimestamp": null,
"labels": {
"name": "frontend"
}
},
"spec": {
"containers": [
{
"name": "openshift-helloworld",
"image": "origin-openshift-sample",
"ports": [
{
"containerPort": 8080,
"protocol": "TCP”
}
],
"env": [
{
"name": "MYSQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "dbsecret",
"key" : "mysql-user"
}
}
},
{
"name": "MYSQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "dbsecret",
"key" : "mysql-password"
}
}
},
{
"name": "MYSQL_DATABASE",
"value": "${MYSQL_DATABASE}"
}
],
"resources": {},
"terminationMessagePath": "/dev/termination-log",
"imagePullPolicy": "IfNotPresent",
"securityContext": {
"capabilities": {},
"privileged": false
}
}
],
"restartPolicy": "Always",
"dnsPolicy": "ClusterFirst"
},
"status": {}
},
模板中的服务定义
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "database",
"creationTimestamp": null
},
"spec": {
"ports": [
{
"name": "db",
"protocol": "TCP",
"port": 5434,
"targetPort": 3306,
"nodePort": 0
}
],
"selector": {
"name": "database
},
"type": "ClusterIP",
"sessionAffinity": "None" },
"status": {
"loadBalancer": {}
}
},
模板中的部署配置定义
{
"kind": "DeploymentConfig",
"apiVersion": "v1",
"metadata": {
"name": "database",
"creationTimestamp": null
},
"spec": {
"strategy": {
"type": "Recreate",
"resources": {}
},
"triggers": [
{
"type": "ConfigChange"
}
],
"replicas": 1,
"selector": {"name": "database"},
"template": {
"metadata": {
"creationTimestamp": null,
"labels": {"name": "database"}
},
"template": {
"metadata": {
"creationTimestamp": null,
"labels": {
"name": "database"
}
},
"spec": {
"containers": [
{
"name": "openshift-helloworld-database",
"image": "ubuntu/mysql-57-ubuntu7:latest",
"ports": [
{
"containerPort": 3306,
"protocol": "TCP"
}
],
"env": [
{
"name": "MYSQL_USER",
"valueFrom": {
"secretKeyRef" : {
"name" : "dbsecret",
"key" : "mysql-user"
}
}
},
{
"name": "MYSQL_PASSWORD",
"valueFrom": {
"secretKeyRef" : {
"name" : "dbsecret",
"key" : "mysql-password"
}
}
},
{
"name": "MYSQL_DATABASE",
"value": "${MYSQL_DATABASE}"
}
],
"resources": {},
"volumeMounts": [
{
"name": "openshift-helloworld-data",
"mountPath": "/var/lib/mysql/data"
}
],
"terminationMessagePath": "/dev/termination-log",
"imagePullPolicy": "Always",
"securityContext": {
"capabilities": {},
"privileged": false
}
}
],
"volumes": [
{
"name": "openshift-helloworld-data",
"emptyDir": {"medium": ""}
}
],
"restartPolicy": "Always",
"dnsPolicy": "ClusterFirst”
}
}
},
"status": {}
},
"parameters": [
{
"name": "MYSQL_USER",
"description": "database username",
"generate": "expression",
"from": "user[A-Z0-9]{3}",
"required": true
},
{
"name": "MYSQL_PASSWORD",
"description": "database password",
"generate": "expression",
"from": "[a-zA-Z0-9]{8}",
"required": true
},
{
"name": "MYSQL_DATABASE",
"description": "database name",
"value": "root",
"required": true
}
],
"labels": {
"template": "application-template-dockerbuild"
}
}
上面的模板文件需要一次性编译完成。我们需要首先将所有内容复制到一个文件中，完成后将其命名为 yaml 文件。
我们需要运行以下命令来创建应用程序。
$ oc new-app application-template-stibuild.json
--> Deploying template openshift-helloworld-sample for "application-template-stibuild.json"
openshift-helloworld-sample
---------
This example shows how to create a simple ruby application in openshift origin v3
* With parameters:
* MYSQL_USER = userPJJ # generated
* MYSQL_PASSWORD = cJHNK3se # generated
* MYSQL_DATABASE = root
--> Creating resources with label app = ruby-helloworld-sample ...
service "frontend" created
route "route-edge" created
imagestream "origin-ruby-sample" created
imagestream "ruby-22-centos7" created
buildconfig "ruby-sample-build" created
deploymentconfig "frontend" created
service "database" created
deploymentconfig "database" created
--> Success
Build scheduled, use 'oc logs -f bc/ruby-sample-build' to track its progress.
Run 'oc status' to view your app.
如果我们希望监控构建，可以使用 -
$ oc get builds NAME TYPE FROM STATUS STARTED DURATION openshift-sample-build-1 Source Git@bd94cbb Running 7 seconds ago 7s
我们可以使用以下命令检查 OpenShift 上部署的应用程序：
$ oc get pods NAME READY STATUS RESTARTS AGE database-1-le4wx 1/1 Running 0 1m frontend-1-e572n 1/1 Running 0 27s frontend-1-votq4 1/1 Running 0 31s opeshift-sample-build-1-build 0/1 Completed 0 1m
我们可以检查应用程序服务是否是根据服务定义创建的
$ oc get services NAME CLUSTER-IP EXTERNAL-IP PORT(S) SELECTOR AGE database 172.30.80.39 <none> 5434/TCP name=database 1m frontend 172.30.17.4 <none> 5432/TCP name=frontend 1m
OpenShift - 构建自动化
在 OpenShift 中，我们有多种方法来自动化构建管道。为此，我们需要创建一个 BuildConfig 资源来描述构建流程。BuildConfig 中的流程可以与 Jenkins 作业定义中的作业定义进行比较。在创建构建流程时，我们必须选择构建策略。
构建配置文件
在 OpenShift 中，BuildConfig 是一个剩余对象，用于连接到 API，然后创建一个新实例。
kind: "BuildConfig"
apiVersion: "v1"
metadata:
name: "<Name of build config file>"
spec:
runPolicy: "Serial"
triggers:
-
type: "GitHub"
github:
secret: "<Secrete file name>"
- type: "Generic"
generic:
secret: "secret101"
-
type: "ImageChange"
source:
type: "<Source of code>"
git:
uri: "https://github.com/openshift/openshift-hello-world"
dockerfile: "FROM openshift/openshift-22-centos7\nUSER example"
strategy:
type: "Source"
sourceStrategy:
from:
kind: "ImageStreamTag"
name: "openshift-20-centos7:latest"
output:
to:
kind: "ImageStreamTag"
name: "origin-openshift-sample:latest"
postCommit:
script: "bundle exec rake test"
在 OpenShift 中，有四种类型的构建策略。
- 源到图像策略
- Docker策略
- 定制策略
- 管道策略
源到图像策略
允许从源代码开始创建容器映像。在此流程中，实际代码首先下载到容器中，然后在其中进行编译。编译后的代码部署在同一个容器内，并且图像是根据该代码构建的。
strategy:
type: "Source"
sourceStrategy:
from:
kind: "ImageStreamTag"
name: "builder-image:latest"
forcePull: true
有多种战略方针。
- 力拉
- 增量构建
- 外部构建
Docker 策略
在此流程中，OpenShift 使用 Dockerfile 构建映像，然后将创建的映像上传到 Docker 注册表。
strategy:
type: Docker
dockerStrategy:
from:
kind: "ImageStreamTag"
name: "ubuntu:latest"
Docker 文件选项可以是 u