发表于 | 分类于

Master节点介绍

master 节点上运行着众多集群的服务组建：

  1. api server ：提供集群的web console以及restful api 服务。

  2. data
    store：数据源，集群的所有动态信息都存储在后端的一个etcd分布式数据库中，默认etcd安装在master上，也可以将etcd部署在集群之外。

  3. scheduler：调度控制器，负责按照用户输入的要求寻找合适的计算节点

  4. replication
    controller：负责监控容器数量，当发现容器数量少于部署定义数量时，出发新的部署。

Node节点介绍

  1. 主要负责介绍master节点指令，运行和维护docker容器

  2. master节点本身也是一个node节点，一般人为的关闭了容器运行功能。

  3. 通过oc get nodes 可以查看系统中的node节点信息。

Project

  1. namespace：在k8s中使用命名空间概念来隔离资源。

  2. project：在openshift中，引入了project概念。

Pod

  1. pod是一种特殊的容器，oc get pods 可以查看pod

  2. 可以近似的认为容器运行在pod内部，一个pod内部可以运行多个容器，pod内多个容器共享pod的网络及存储资源。

  3. 查看pod日志：oc logs

  4. 进入容器内部：oc rsh

Service

  1. service对象与一个或者多个pod关联，每个service会分配一个ip地址，这个地址相对恒定，通过这个IP地址和端口，请求会被转发到pod相应的端口之上。

  2. service起到了代理的作用，在相互依赖的容器之间实现了解耦。

  3. oc get svc 查看servie

  4. service IP地址是一个虚拟IP，只有在集群内的节点和容器可以识别。

  5. 除了IP地址访问service，还可以通过域名访问service。

  6. master内置DNS服务器，负责解析这个域名

Router

  1. 负责将集群外部的请求转发到集群的容器。

发表于 | 分类于

创建S2I项目

s2i create nginx-centos7-s2i nginx-centos7
./media/image1.png

准备S2I脚本

assemble

#!/bin/bash -e # # S2I assemble script for the ‘nginx-centos7’ image. # The ‘assemble’ script builds your application source so that it is ready to run. # # For more information refer to the documentation: # https://github.com/openshift/source-to-image/blob/master/docs/builder_image.md # if [[ “\$1” == “-h” ]]; then # If the ‘nginx-centos7’ assemble script is executed with ‘-h’ flag, # print the usage. exec /usr/libexec/s2i/usage fi # Restore artifacts from the previous build (if they exist). # We set them here just for show, but you will need to set this up with your logic # according to the application directory that you chose. #if [ “\$(ls /tmp/artifacts/ 2>/dev/null)” ]; then # echo “—> Restoring build artifacts…” # mv /tmp/artifacts/* \ #fi # Override the default nginx index.html file. # This is what we consider in this example ‘installing the application’ # here you can go ahead an replace this with the actual building of python modules, # bundle install, and anything else you need. echo “—> Building and installing application from source…” if [ -f /tmp/src/nginx.conf ]; then mv /tmp/src/nginx.conf /etc/nginx/nginx.conf fi if [ “\$(ls -A /tmp/src)” ]; then mv /tmp/src/* /usr/share/nginx/html/ fi

run

#!/bin/bash -e # The run script executes the server that runs your application. # # For more information see the documentation: # https://github.com/openshift/source-to-image/blob/master/docs/builder_image.md # # We will turn off daemonizing for the nginx process so that the container # doesn’t exit after the process runs. exec /usr/sbin/nginx -g “daemon off;”

save-artifacts

#!/bin/sh -e # # S2I save-artifacts script for the ‘nginx-centos7’ image. # The save-artifacts script streams a tar archive to standard output. # The archive contains the files and folders you want to re-use in the next build. # # For more information see the documentation: # https://github.com/openshift/source-to-image/blob/master/docs/builder_image.md # #tar cf - \

usage

#!/bin/bash -e cat \<\<EOF This is the nginx-centos7 S2I image: To use it, install S2I: https://github.com/openshift/source-to-image Sample invocation: s2i build test/test-app nginx-centos7 nginx-centos7-app You can then run the resulting image via: docker run -d -p 8080:8080 nginx-centos7-app and see the test via http://localhost:8080 EOF

准备Dockfile

# nginx-centos7 # Here you can use whatever base image is relevant for your application. FROM centos:centos7 # Here you can specify the maintainer for the image that you’re building LABEL maintainer=”Chen Fei \<chenf\@inno-view.cn>“ # Export an environment variable that provides information about the application version. # Replace this with the version for your application. ENV NGINX_VERSION=1.6.3 # Set the labels that are used for OpenShift to describe the builder image. LABEL io.k8s.description=”Nginx Webserver” \ io.k8s.display-name=”Nginx 1.6.3” \ io.openshift.expose-services=”8080:http” \ io.openshift.tags=”builder,webserver,html,nginx” \ # this label tells s2i where to find its mandatory scripts # (run, assemble, save-artifacts) io.openshift.s2i.scripts-url=”image:///usr/libexec/s2i” # Install the nginx web server package and clean the yum cache RUN yum install -y epel-release && \ yum install -y –setopt=tsflags=nodocs nginx && \ yum clean all # Change the default port for nginx # Required if you plan on running images as a non-root user). RUN sed -i ‘s/80/8080/‘ /etc/nginx/nginx.conf RUN sed -i ‘s/user nginx;//‘ /etc/nginx/nginx.conf # Copy the S2I scripts to /usr/libexec/s2i since we set the label that way COPY ./s2i/bin/ /usr/libexec/s2i RUN chown -R 1001:1001 /usr/share/nginx RUN chown -R 1001:1001 /var/log/nginx RUN chown -R 1001:1001 /var/lib/nginx RUN touch /run/nginx.pid RUN chown -R 1001:1001 /run/nginx.pid RUN chown -R 1001:1001 /etc/nginx USER 1001 # Set the default port for applications built using this image EXPOSE 8080 # Modify the usage script in your application dir to inform the user how to run # this image. CMD [“/usr/libexec/s2i/usage”]

生成Builder Image

docker build -t nginx-centos7 .
./media/image2.png

上传OpenShift

上传到Harbor

docker tag nginx-centos7:latest dtr.ivops.cn:5443/openshift-chenf/nginx-centos7:latest
docker push dtr.ivops.cn:5443/openshift-chenf/nginx-centos7:latest

创建Image Stream

oc import-image dtr.ivops.cn:5443/openshift-chenf/nginx-centos7 -n openshift –confirm –insecure
添加Builder tags
oc edit is nginx-centos7 -n openshift
./media/image3.png
./media/image4.png

根据源代码构建

./media/image5.png
Builds:
./media/image6.png
完成
./media/image7.png
验证应用
./media/image8.png

代码更新

代码侧有版本更新，重新构建
./media/image9.png
./media/image10.png
./media/image11.png

发表于 | 分类于

应用容器化方式

  • 应用容器化，常见的方法有以下三种：
名称 举例 类别 适用场景 特点
本地构建 工程师编写Dockerfile，并手工在一台或多台主机上手工执行Docker Build命令构建应用镜像 人工 开发测试 简单
CI构建 Jenkins集群在CI流程中调用Maven执行构建，Maven 通过插件按指定的Dockerfile生成应用的镜像。 自动化 传统持续集成 常规CI方案
Source 2 Image OpenShift在隔离的容器环境中进行应用的构建编译并生成应用的容器镜像 自动化 容器及微服务场景下的持续集成 基于容器集群的CI方案

  • 每个开发团队均需要编写Dockerfile

  • 重复多次执行时间和人力成本陡增

  • 每个开发团队均需要编写Dockerfile

  • 微服务多语言多版本混合构建时无隔离

  • 构建资源池不可动态扩展

  • 资源利用率较低

  • 开发团队通过容器镜像精确定义构建环境

  • 基于容器的构建环境，提供更好的隔离性

  • 满足多语言多版本微服务混合构建的场景

  • 构建资源池可动态扩展，更灵活

  • 构建与应用运行共享资源池降低运维工作量

  • 资源按需投入及回收，利用率高

  • 第一种本地构建最常见，也比较简单，但效率太低。

  • 第二种方式是通过CI构建。这种方式则是比较传统的方法。需要指出的：CI/CD的实现，与容器并无必然的联系。在容器火之前，很多客户也基于Jenkins和虚拟机实现了CD/CD。只是容器轻量级的优势，更容易实现CI/CD。在红帽Openshift中，我们可以通过CI构建实现容器镜像。这种构建方式，实际上是在openshift中部署Jenkins
    Slave Pod,在Slave Pod实现构建。红帽提供四种Jenkins Slave
    Pod的镜像（根据应用开发语言的不同），有基于maven的，有基于nodejs的、基于.net的、也有基础镜像（使用者基于基础镜像进行构建）。

  • 第三种方式是通过S2I的方式构建应用镜像。这种方式有第二种方式构建的优点（构建好的应用客户实现CI），并且比第二种方式效率更高、适用多种开发语言。

S2I的应用容器化过程

  • S2I方式构建通常有6个步骤，下图为构建一个tomcat容器应用镜像示例：

1．装S2I命令行工具：
指的是在构建builder的rhel/centos主机上安装s2i的命令行工具
2．选定base image：
也就是说，我们选则一个最初的原始docker image。在基础镜像的选择上，也需要一些考量。比如：我可以选择一个docker.io上的tomcat 镜像直接用，也可以选择一个centos的docker image安装tomcat。
3．编写S2I脚本：
S2I有四个脚本。在S2I脚本的编写中，我的经验是采取“反推法”。也就是应用镜像运行起来，到底需要assmble和run做什么，这两个脚本就应该怎么写。 在这个阶段，我们还需要书写Dockerfile，准备基于第二步选定的base image构建新的builder image。Dockerfile中需要定义S2I脚本的拷贝和执行，base image的名称、和应用相关的一些目录权限、用户和权限等。
4．生成builder image。
5．选定源码库。
6．根据选定的代码地址和builder image，构建应用镜像并部署。

安装S2I命令行工具

下载地址：https://github.com/openshift/source-to-image/releases
curl -L -O https://github.com/openshift/source-to-image/releases/download/v1.1.8/source-to-image-v1.1.8-e3140d01-linux-amd64.tar.gz
tar zxvf source-to-image-v1.1.8-e3140d01-linux-amd64.tar.gz
mv s2i sti /usr/bin/
s2i version
./media/image2.png

选定base image

  • 基于S2I构建一个tomcat容器应用镜像

  • 选择centos的镜像，然后在dockerfile中指定安装tomcat

  • base image选择 openshift/base-centos7

编写S2I脚本并书写Dockerfile

  • 一个符合S2I/B2I的building image，在bin目录下，是需要包含如下四个脚本的：
assemble脚本： 这个脚本负责将外部代码库的代码下载到本地，并且进行编译打包。
run脚本： 这个脚本负责运行assemble编译好的应用。
save-artifacts脚本： save-artifacts脚本负责将构建所需要的所有依赖包收集到一个tar文件中。save-artifacts的好处是可以加速构建的过程。
usage脚本： usage脚本是告诉使用者如何使用镜像。
在S2I的四个脚本中，通常我们只会用到assemble和run两个脚本。实际上脚本的书写，和应用是关系很大的。

创建S2I目录结构

mkdir tomcat8-jdk8 && cd tomcat8-jdk8
mkdir -p .s2i/bin touch .s2i/bin/assemble.sh touch .s2i/bin/run.sh touch .s2i/bin/usage.sh
#也可以使用s2i create直接创建

配置assemble

请记住如下脚本中的”WAR’s copied”输出，这在后文中将作为应用build成功的标志。 assemble 脚本的作用，就是将代码库的代码，拷贝到\$CATALINA_HOME/webapps下去运行。\$CATALINA_HOME变量在dockerfile中被指定成/tomcat
echo “—> Installing application source…” cp -Rf /tmp/src/. \$CATALINA_HOME/webapps echo “WAR’s copied”

配置run

run脚本的作用，就是当build包的应用镜像部署成功以后，启动镜像中的tomcat应用。
\${CATALINA_HOME}/bin/catalina.sh run

配置usage

#!/bin/bash -e cat \<\<EOF This is not an application image, please refer this documentation on using this image https://github.com/debianmaster/openshift-s2i-example.git EOF

配置save-artifacts

#curl -o \$CATALINA_HOME/webapps/ROOT.war -O \${WAR_FILE_URL}

  1. 编写Dockerfile

    1. 指定base image并安装依赖包
vim tomcat8-jdk8/Dockerfile
FROM openshift/base-centos7 MAINTAINER Chen Fei (chenf\@inno-view.cn) ENV BUILDER_VERSION 1.1 RUN yum install wget -y; \ yum install tar -y; \ yum install unzip -y; \ yum install ca-certificates -y;\ yum install sudo -y;\ yum clean all -y ENV TOMCAT_MAJOR_VERSION 8 ENV TOMCAT_MINOR_VERSION 8.0.32 ENV CATALINA_HOME /tomcat

安装jdk和tomcat

# Install openjdk 1.8 RUN yum install java-1.8.0-openjdk.x86_64* -y && \ yum clean all -y && \ rm -rf /var/lib/apt/lists/* # INSTALL TOMCAT WORKDIR / RUN wget -q -e use_proxy=yes https://archive.apache.org/dist/tomcat/tomcat-8/v8.0.32/bin/apache-tomcat-8.0.32.tar.gz && \ tar -zxf apache-tomcat-*.tar.gz &&\ rm -f apache-tomcat-*.tar.gz && \ mv apache-tomcat* tomcat ENV JAVA_OPTS=”-Dtuf.environment=DEV -Dtuf.appFiles.rootDirectory=/TempDirRoot”

创建用户、目录

RUN groupadd -r safe RUN useradd -r -g safe safe RUN mkdir -p /tomcat/webapps /TempDirRoot /usr/libexec/s2i /tmp/src RUN chmod -R 755 /tomcat /TempDirRoot /tmp/src /usr/libexec/s2i /tomcat/bin RUN chown -R 1001:1001 /tomcat /TempDirRoot /tmp/src /usr/libexec/s2i /tomcat/bin RUN chmod -R 777 /tomcat /TempDirRoot RUN cd /tomcat/webapps/; rm -rf ROOT docs examples host-manager manager COPY ./.s2i/bin/ /usr/libexec/s2i RUN chmod -R 755 /usr/libexec/s2i USER 1001 EXPOSE 8080 CMD \$STI_SCRIPTS_PATH/usage

生成builder image

生成builder image

命名名字为tomcat8-jdk8
docker build -t tomcat8-jdk8 .

验证builder image

docker run -it d67311e72289 /bin/bash
前面拷贝的文件都在
./media/image3.png

OpenShift使用builder image

上传到内部docker registry

docker tag tomcat8-jdk8:latest dtr.ivops.cn:5443/openshift-chenf/tomcat8-jdk8:latest
docker push dtr.ivops.cn:5443/openshift-chenf/tomcat8-jdk8:latest
./media/image4.png

创建Image Stream

要导入到openshift项目中，以使该Image Stream可以被其他项目引用
oc import-image dtr.ivops.cn:5443/openshift-chenf/tomcat8-jdk8 -n openshift –confirm –insecure
./media/image5.png
为了让openshift识别出这个镜像是S2I的Builder镜像，需要编辑刚刚导入的Image Stream。添加注解”tags”:”builder”
oc edit is tomcat8-jdk8
./media/image6.png
这样，在web控制台就能看到
./media/image7.png

选定代码库

示例使用GitHub上的代码
URL：https://github.com/debianmaster/sample-binaries.git
war中的内容：
./media/image8.tiff
查看war包中的index.html:
./media/image9.tiff
查看hello.jsp中的代码：
./media/image10.tiff

根据选定的代码和builder image，构建应用镜像并部署

进入project
oc project test
指定builder image的image stream和代码的git地址:
oc new-app tomcat8-jdk8~https://github.com/debianmaster/sample-binaries.git –name=’tomcat8-jdk8-war’
./media/image11.png

Build过程

第一部分：其实就是assemble脚本执行成功后的输出 第二部分：镜像构建成功以后，会先push到docker registry中
./media/image12.png

触发DC

再会根据build成功的镜像，触发dc，也就是部署一个应用的容器
./media/image13.png

部署完成

./media/image14.png

添加route

./media/image15.png
./media/image16.png

测试访问

dnsmasq添加解析
vim /etc/dnsmasq.d/local.conf
./media/image17.png
systemctl restart dnsmasq
./media/image18.png

生成Template

导出成yaml格式的template
oc export is,bc,dc,svc –as-template=tomcat8-jdk8 > ./tomcat8-jdk8.yml
导入
oc create -f tomcat8-jdk8.yml -n openshift
./media/image19.png

发表于 | 分类于

准备Rabbitmq镜像

Dockfile

FROM ubuntu:14.04 MAINTAINER Chen Fei \<chenf\@inno-view.cn> LABEL io.k8s.description=”rabbitmq is a multi-user, multi-threaded message broker server” \ io.k8s.display-name=”Rabbitmq-server lastest” \ io.openshift.expose-services=”5672:rabbitmq” \ io.openshift.tags=”rabbitmq” EXPOSE 5672/tcp EXPOSE 25672/tcp USER root ADD root / RUN echo ‘deb http://www.rabbitmq.com/debian/ testing main’ \ sudo tee /etc/apt/sources.list.d/rabbitmq.list RUN apt-get update RUN apt-get install -y wget RUN wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc \ sudo apt-key add - RUN apt-get update RUN apt-get install -y rabbitmq-server RUN echo -n ‘LCQLSHVOPZFHRUXMMAPF’ > /var/lib/rabbitmq/.erlang.cookie RUN chown -R rabbitmq. /var/lib/rabbitmq RUN chmod 400 /var/lib/rabbitmq/.erlang.cookie ADD rabbitmq-env.conf /etc/rabbitmq/rabbitmq-env.conf ENTRYPOINT [“/usr/bin/container-entrypoint.sh”]

生成镜像

docker build -t rabbitmq .
./media/image1.png

上传OpenShift

上传到Harbor

docker tag rabbitmq dtr.ivops.cn:5443/openshift-chenf/rabbitmq
docker push dtr.ivops.cn:5443/openshift-chenf/rabbitmq
./media/image2.png

部署应用

创建rabbitmq用户

oc create serviceaccount rabbitmq
oc adm policy add-scc-to-user anyuid -z rabbitmq

部署rabbitmq

oc create -f rabbitmq.yaml
apiVersion: v1 kind: Service metadata: annotations: service.alpha.kubernetes.io/tolerate-unready-endpoints: “true” name: rabbitmq labels: app: rabbit spec: ports: - port: 5672 name: rabbit clusterIP: None selector: app: rabbit — apiVersion: apps/v1beta1 kind: StatefulSet metadata: name: rabbit spec: serviceName: “rabbitmq” replicas: 3 template: metadata: labels: app: rabbit annotations: pod.alpha.kubernetes.io/initialized: “true” spec: containers: - name: rabbit image: dtr.ivops.cn:5443/openshift-chenf/rabbitmq imagePullPolicy: IfNotPresent ports: - containerPort: 5672 name: rabbit - containerPort: 25672 name: bean readinessProbe: exec: command: - /usr/share/container-scripts/rabbitmq/readiness-probe.sh initialDelaySeconds: 15 timeoutSeconds: 5 env: - name: POD_NAMESPACE valueFrom: fieldRef: apiVersion: v1 fieldPath: metadata.namespace - name: RABBITMQ_USE_LONGNAME value: “true” - name: RABBITMQ_NODENAME value: “rabbit” nodeSelector: region: infra serviceAccount: rabbitmq securityContext: {} serviceAccountName: rabbitmq
./media/image3.png
./media/image4.png

集群状态

./media/image5.png