Nó là một hệ thống giám sát và cảnh báo. Nó được xây dựng tại SoundCloud và có nguồn mở vào năm 2012. Nó xử lý dữ liệu đa chiều rất tốt.

Prometheus có nhiều thành phần tham gia giám sát –

• Prometheus – Đây là thành phần cốt lõi có chức năng quét và lưu trữ dữ liệu.
• Khám phá nút Prometheus – Nhận ma trận cấp máy chủ và hiển thị chúng với Prometheus.
• Ranch-eye – là một haproxy và hiển thị các số liệu thống kê của Cvisor cho Prometheus.
• Grafana – Trực quan hóa dữ liệu.
• InfuxDB – Cơ sở dữ liệu chuỗi thời gian được sử dụng đặc biệt để lưu trữ dữ liệu từ chủ trang trại.
• Prom-ranch-exportorter – Đây là một ứng dụng node.js đơn giản, giúp truy vấn máy chủ Rancher về trạng thái của ngăn xếp dịch vụ.

Sematext Docker Agent

Nó là một đại lý thu thập nhật ký, sự kiện và chỉ số nhận biết Docker hiện đại. Nó chạy như một vùng chứa nhỏ trên mọi máy chủ Docker và thu thập nhật ký, số liệu và sự kiện cho tất cả các nút và vùng chứa cụm. Nó phát hiện ra tất cả các vùng chứa (một nhóm có thể chứa nhiều vùng chứa) bao gồm các vùng chứa cho các dịch vụ cốt lõi của Kubernetes, nếu các dịch vụ cốt lõi được triển khai trong các vùng chứa Docker. Sau khi triển khai, tất cả nhật ký và chỉ số sẽ có sẵn ngay lập tức.

Triển khai đại lý cho các nút

Kubernetes cung cấp DeamonSets đảm bảo các nhóm được thêm vào cụm.

Định cấu hình SemaText Docker Agent

Nó được cấu hình thông qua các biến môi trường.

• Nhận một tài khoản miễn phí tại apps.sematext.com , nếu bạn chưa có.
• Tạo Ứng dụng SPM loại “Docker” để nhận Mã thông báo ứng dụng SPM. Ứng dụng SPM sẽ lưu trữ sự kiện và số liệu hiệu suất Kubernetes của bạn.
• Tạo Ứng dụng Logsene để nhận Mã thông báo ứng dụng Logsene. Ứng dụng Logsene sẽ lưu giữ nhật ký Kubernetes của bạn.
• Chỉnh sửa giá trị của LOGSENE_TOKEN và SPM_TOKEN trong định nghĩa DaemonSet như hình dưới đây.
  • Lấy mẫu sematext-agent-daemonset.yml (văn bản thô thô) mới nhất (cũng được hiển thị bên dưới).
  • Lưu trữ nó ở đâu đó trên đĩa.
  • Thay thế các trình giữ chỗ SPM_TOKEN và LOGSENE_TOKEN bằng các mã thông báo SPM và Logsene App của bạn.

Tạo đối tượng DaemonSet

apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
   name: sematext-agent
spec:
   template:
      metadata:
         labels:
            app: sematext-agent
      spec:
         selector: {}
         dnsPolicy: "ClusterFirst"
         restartPolicy: "Always"
         containers:
         - name: sematext-agent
            image: sematext/sematext-agent-docker:latest
            imagePullPolicy: "Always"
            env:
            - name: SPM_TOKEN
               value: "REPLACE THIS WITH YOUR SPM TOKEN"
            - name: LOGSENE_TOKEN
               value: "REPLACE THIS WITH YOUR LOGSENE TOKEN"
            - name: KUBERNETES
               value: "1"
            volumeMounts:
               - mountPath: /var/run/docker.sock
                  name: docker-sock
               - mountPath: /etc/localtime
                  name: localtime
            volumes:
               - name: docker-sock
                  hostPath:
                     path: /var/run/docker.sock
               - name: localtime
                  hostPath:
                     path: /etc/localtime

Chạy Sematext Agent Docker với kubectl

$ kubectl create -f sematext-agent-daemonset.yml
daemonset "sematext-agent-daemonset" created

Nhật ký Kubernetes

Nhật ký của vùng chứa Kubernetes không khác nhiều so với nhật ký vùng chứa Docker. Tuy nhiên, người dùng Kubernetes cần xem nhật ký cho các nhóm được triển khai. Do đó, sẽ rất hữu ích nếu có sẵn thông tin cụ thể về Kubernetes để tìm kiếm nhật ký, chẳng hạn như –

• Không gian tên Kubernetes
• Tên nhóm Kubernetes
• Tên vùng chứa Kubernetes
• Tên hình ảnh Docker
• Kubernetes UID

Sử dụng ELK Stack và LogSpout

Ngăn xếp ELK bao gồm Elasticsearch, Logstash và Kibana. Để thu thập và chuyển tiếp nhật ký đến nền tảng ghi nhật ký, chúng tôi sẽ sử dụng LogSpout (mặc dù có các tùy chọn khác như FluentD). Đoạn mã sau đây cho thấy cách thiết lập cụm ELK trên Kubernetes và tạo dịch vụ cho ElasticSearch

apiVersion: v1
kind: Service
metadata:
   name: elasticsearch
   namespace: elk
   labels:
      component: elasticsearch
spec:
   type: LoadBalancer
   selector:
      component: elasticsearch
   ports:
   - name: http
      port: 9200
      protocol: TCP
   - name: transport
      port: 9300
      protocol: TCP

Tạo bộ điều khiển sao chép

apiVersion: v1
kind: ReplicationController
metadata:
   name: es
   namespace: elk
   labels:
      component: elasticsearch
spec:
   replicas: 1
   template:
      metadata:
         labels:
            component: elasticsearch
spec:
serviceAccount: elasticsearch
containers:
   - name: es
      securityContext:
      capabilities:
      add:
      - IPC_LOCK
   image: quay.io/pires/docker-elasticsearch-kubernetes:1.7.1-4
   env:
   - name: KUBERNETES_CA_CERTIFICATE_FILE
   value: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
   - name: NAMESPACE
   valueFrom:
      fieldRef:
         fieldPath: metadata.namespace
   - name: "CLUSTER_NAME"
      value: "myesdb"
   - name: "DISCOVERY_SERVICE"
      value: "elasticsearch"
   - name: NODE_MASTER
      value: "true"
   - name: NODE_DATA
      value: "true"
   - name: HTTP_ENABLE
      value: "true"
ports:
- containerPort: 9200
   name: http
   protocol: TCP
- containerPort: 9300
volumeMounts:
- mountPath: /data
   name: storage
volumes:
   - name: storage
      emptyDir: {}

URL Kibana

Đối với Kibana, chúng tôi cung cấp URL Elasticsearch dưới dạng biến môi trường.

- name: KIBANA_ES_URL
value: "http://elasticsearch.elk.svc.cluster.local:9200"
- name: KUBERNETES_TRUST_CERT
value: "true"

Giao diện người dùng Kibana sẽ có thể truy cập được tại cổng container 5601 và kết hợp cổng máy chủ / cổng tương ứng. Khi bạn bắt đầu, sẽ không có bất kỳ dữ liệu nào trong Kibana (dự kiến ​​là bạn chưa đẩy bất kỳ dữ liệu nào).

The post Kubernetes – Giám sát appeared first on Dongthoigian.net.

Để thiết lập cơ sở hạ tầng có thể mở rộng trong GCE, trước tiên chúng ta cần có một dự án GCE đang hoạt động với các tính năng giám sát đám mây của Google, ghi nhật ký đám mây của Google và trình xếp chồng được bật.

Đầu tiên, chúng ta sẽ thiết lập một cụm với vài nút đang chạy trong đó. Sau khi hoàn tất, chúng ta cần thiết lập biến môi trường sau.

Biến môi trường

export NUM_NODES = 2
export KUBE_AUTOSCALER_MIN_NODES = 2
export KUBE_AUTOSCALER_MAX_NODES = 5
export KUBE_ENABLE_CLUSTER_AUTOSCALER = true

Sau khi hoàn tất, chúng tôi sẽ bắt đầu cụm bằng cách chạy kube-up.sh . Thao tác này sẽ tạo một cụm cùng với tính năng bổ sung tự động vô hướng của cụm.

./cluster/kube-up.sh

Khi tạo cụm, chúng ta có thể kiểm tra cụm của mình bằng cách sử dụng lệnh kubectl sau.

$ kubectl get nodes
NAME                             STATUS                       AGE
kubernetes-master                Ready,SchedulingDisabled     10m
kubernetes-minion-group-de5q     Ready                        10m
kubernetes-minion-group-yhdx     Ready                        8m

Bây giờ, chúng ta có thể triển khai một ứng dụng trên cụm và sau đó kích hoạt tính năng tự động phân loại pod ngang. Điều này có thể được thực hiện bằng cách sử dụng lệnh sau.

$ kubectl autoscale deployment <Application Name> --cpu-percent = 50 --min = 1 --
max = 10

Lệnh trên cho thấy rằng chúng tôi sẽ duy trì ít nhất một và tối đa 10 bản sao của POD khi tải trên ứng dụng tăng lên.

Chúng ta có thể kiểm tra trạng thái của autoscaler bằng cách chạy lệnh $ kubclt get hpa . Chúng tôi sẽ tăng tải trên các nhóm bằng lệnh sau.

$ kubectl run -i --tty load-generator --image = busybox /bin/sh
$ while true; do wget -q -O- http://php-apache.default.svc.cluster.local; done

Chúng ta có thể kiểm tra hpa bằng cách chạy lệnh $ kubectl get hpa 

$ kubectl get hpa
NAME         REFERENCE                     TARGET CURRENT
php-apache   Deployment/php-apache/scale    50%    310%

MINPODS  MAXPODS   AGE
  1        20      2m
  
$ kubectl get deployment php-apache
NAME         DESIRED    CURRENT    UP-TO-DATE    AVAILABLE   AGE
php-apache      7          7           7  

Chúng ta có thể kiểm tra số lượng pod đang chạy bằng lệnh sau.

jsz@jsz-desk2:~/k8s-src$ kubectl get pods
php-apache-2046965998-3ewo6 0/1        Pending 0         1m
php-apache-2046965998-8m03k 1/1        Running 0         1m
php-apache-2046965998-ddpgp 1/1        Running 0         5m
php-apache-2046965998-lrik6 1/1        Running 0         1m
php-apache-2046965998-nj465 0/1        Pending 0         1m
php-apache-2046965998-tmwg1 1/1        Running 0         1m
php-apache-2046965998-xkbw1 0/1        Pending 0         1m

Và cuối cùng, chúng ta có thể nhận được trạng thái của nút.

$ kubectl get nodes
NAME                             STATUS                        AGE
kubernetes-master                Ready,SchedulingDisabled      9m
kubernetes-minion-group-6z5i     Ready                         43s
kubernetes-minion-group-de5q     Ready                         9m
kubernetes-minion-group-yhdx     Ready                         9m

Kubernetes – Thiết lập Trang tổng quan

Việc thiết lập bảng điều khiển Kubernetes bao gồm một số bước với một bộ công cụ được yêu cầu làm điều kiện tiên quyết để thiết lập nó.

• Docker (1.3+)
• nodejs (4.2.2+)
• npm (1,3+)
• java (7+)
• nuốt nước bọt (3,9+)
• Kubernetes (1.1.2+)

Thiết lập Trang tổng quan

$ sudo apt-get update && sudo apt-get upgrade

Installing Python
$ sudo apt-get install python
$ sudo apt-get install python3

Installing GCC
$ sudo apt-get install gcc-4.8 g++-4.8

Installing make
$ sudo apt-get install make

Installing Java
$ sudo apt-get install openjdk-7-jdk

Installing Node.js
$ wget https://nodejs.org/dist/v4.2.2/node-v4.2.2.tar.gz
$ tar -xzf node-v4.2.2.tar.gz
$ cd node-v4.2.2
$ ./configure
$ make
$ sudo make install

Installing gulp
$ npm install -g gulp
$ npm install gulp

Xác minh các phiên bản

Java Version
$ java –version
java version "1.7.0_91"
OpenJDK Runtime Environment (IcedTea 2.6.3) (7u91-2.6.3-1~deb8u1+rpi1)
OpenJDK Zero VM (build 24.91-b01, mixed mode)

$ node –v
V4.2.2

$ npn -v
2.14.7

$ gulp -v
[09:51:28] CLI version 3.9.0

$ sudo gcc --version
gcc (Raspbian 4.8.4-1) 4.8.4
Copyright (C) 2013 Free Software Foundation, Inc. This is free software; 
see the source for copying conditions. There is NO warranty; not even for 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Cài đặt GO

$ git clone https://go.googlesource.com/go
$ cd go
$ git checkout go1.4.3
$ cd src

Building GO
$ ./all.bash
$ vi /root/.bashrc
In the .bashrc
   export GOROOT = $HOME/go
   export PATH = $PATH:$GOROOT/bin
   
$ go version
go version go1.4.3 linux/arm

Cài đặt Bảng điều khiển Kubernetes

$ git clone https://github.com/kubernetes/dashboard.git
$ cd dashboard
$ npm install -g bower

Chạy Bảng điều khiển

$ git clone https://github.com/kubernetes/dashboard.git
$ cd dashboard
$ npm install -g bower
$ gulp serve
[11:19:12] Requiring external module babel-core/register
[11:20:50] Using gulpfile ~/dashboard/gulpfile.babel.js
[11:20:50] Starting 'package-backend-source'...
[11:20:50] Starting 'kill-backend'...
[11:20:50] Finished 'kill-backend' after 1.39 ms
[11:20:50] Starting 'scripts'...
[11:20:53] Starting 'styles'...
[11:21:41] Finished 'scripts' after 50 s
[11:21:42] Finished 'package-backend-source' after 52 s
[11:21:42] Starting 'backend'...
[11:21:43] Finished 'styles' after 49 s
[11:21:43] Starting 'index'...
[11:21:44] Finished 'index' after 1.43 s
[11:21:44] Starting 'watch'...
[11:21:45] Finished 'watch' after 1.41 s
[11:23:27] Finished 'backend' after 1.73 min
[11:23:27] Starting 'spawn-backend'...
[11:23:27] Finished 'spawn-backend' after 88 ms
[11:23:27] Starting 'serve'...
2016/02/01 11:23:27 Starting HTTP server on port 9091
2016/02/01 11:23:27 Creating API client for
2016/02/01 11:23:27 Creating Heapster REST client for http://localhost:8082
[11:23:27] Finished 'serve' after 312 ms
[BS] [BrowserSync SPA] Running...
[BS] Access URLs:
--------------------------------------
Local: http://localhost:9090/
External: http://192.168.1.21:9090/
--------------------------------------
UI: http://localhost:3001
UI External: http://192.168.1.21:3001
--------------------------------------
[BS] Serving files from: /root/dashboard/.tmp/serve
[BS] Serving files from: /root/dashboard/src/app/frontend
[BS] Serving files from: /root/dashboard/src/app

Bảng điều khiển Kubernetes

Kubernetes – Giám sát (xem thêm)

The post Kubernetes – Tự động chia tỷ lệ appeared first on Dongthoigian.net.

• Bằng cách tải xuống
• Từ tệp Docker

Bằng cách tải xuống

Hình ảnh hiện có có thể được tải xuống từ trung tâm Docker và có thể được lưu trữ trên sổ đăng ký Docker cục bộ. Để làm điều đó, hãy chạy lệnh kéo Docker .

$ docker pull --help
Usage: docker pull [OPTIONS] NAME[:TAG|@DIGEST]
Pull an image or a repository from the registry
   -a, --all-tags = false     Download all tagged images in the repository
   --help = false             Print usage

Sau đây sẽ là đầu ra của đoạn mã trên.

Ảnh chụp màn hình ở trên hiển thị một tập hợp các hình ảnh được lưu trữ trong sổ đăng ký Docker cục bộ của chúng tôi.

Nếu chúng ta muốn xây dựng một vùng chứa từ hình ảnh chứa một ứng dụng để kiểm tra, chúng ta có thể thực hiện bằng cách sử dụng lệnh Docker run.

$ docker run –i –t unbunt /bin/bash

Từ tệp Docker

Để tạo một ứng dụng từ tệp Docker, trước tiên chúng ta cần tạo một tệp Docker. Sau đây là một ví dụ về tệp Jenkins Docker.

FROM ubuntu:14.04
MAINTAINER vipinkumarmishra@virtusapolaris.com
ENV REFRESHED_AT 2017-01-15
RUN apt-get update -qq && apt-get install -qqy curl
RUN curl https://get.docker.io/gpg | apt-key add -
RUN echo deb http://get.docker.io/ubuntu docker main > /etc/apt/
sources.list.d/docker.list
RUN apt-get update -qq && apt-get install -qqy iptables ca-
certificates lxc openjdk-6-jdk git-core lxc-docker
ENV JENKINS_HOME /opt/jenkins/data
ENV JENKINS_MIRROR http://mirrors.jenkins-ci.org
RUN mkdir -p $JENKINS_HOME/plugins
RUN curl -sf -o /opt/jenkins/jenkins.war -L $JENKINS_MIRROR/war-
stable/latest/jenkins.war
RUN for plugin in chucknorris greenballs scm-api git-client git 
ws-cleanup ;\
do curl -sf -o $JENKINS_HOME/plugins/${plugin}.hpi \
-L $JENKINS_MIRROR/plugins/${plugin}/latest/${plugin}.hpi 
; done
ADD ./dockerjenkins.sh /usr/local/bin/dockerjenkins.sh
RUN chmod +x /usr/local/bin/dockerjenkins.sh
VOLUME /var/lib/docker
EXPOSE 8080
ENTRYPOINT [ "/usr/local/bin/dockerjenkins.sh" ]

Khi tệp ở trên được tạo, hãy lưu nó với tên Dockerfile và cd vào đường dẫn tệp. Sau đó, chạy lệnh sau.

$ sudo docker build -t jamtur01/Jenkins .

Sau khi hình ảnh được tạo, chúng tôi có thể kiểm tra xem hình ảnh có hoạt động tốt hay không và có thể chuyển đổi thành vùng chứa.

$ docker run –i –t jamtur01/Jenkins /bin/bash

Kubernetes – Triển khai ứng dụng

Triển khai là một phương pháp chuyển đổi hình ảnh sang vùng chứa và sau đó phân bổ những hình ảnh đó vào các nhóm trong cụm Kubernetes. Điều này cũng giúp thiết lập cụm ứng dụng bao gồm triển khai dịch vụ, nhóm, bộ điều khiển nhân rộng và tập hợp bản sao. Cụm có thể được thiết lập theo cách mà các ứng dụng được triển khai trên nhóm có thể giao tiếp với nhau.

Trong thiết lập này, chúng tôi có thể có cài đặt cân bằng tải trên đầu một ứng dụng chuyển hướng lưu lượng truy cập đến một nhóm các nhóm và sau đó chúng giao tiếp với các nhóm phụ trợ. Giao tiếp giữa các nhóm xảy ra thông qua đối tượng dịch vụ được tích hợp trong Kubernetes.

Tệp Yaml của Trình cân bằng tải Ngnix

apiVersion: v1
kind: Service
metadata:
   name: oppv-dev-nginx
      labels:
         k8s-app: omni-ppv-api
spec:
   type: NodePort
   ports:
   - port: 8080
      nodePort: 31999
      name: omninginx
   selector:
      k8s-app: appname
      component: nginx
      env: dev

Ngnix Replication Controller Yaml

apiVersion: v1
kind: ReplicationController
metadata:
   name: appname
spec:
   replicas: replica_count
   template:
      metadata:
         name: appname
         labels:
            k8s-app: appname
            component: nginx
               env: env_name
spec:
   nodeSelector:
      resource-group: oppv
   containers:
      - name: appname
      image: IMAGE_TEMPLATE
      imagePullPolicy: Always
      ports:
         - containerPort: 8080
         resources:
            requests:
               memory: "request_mem"
               cpu: "request_cpu"
            limits:
               memory: "limit_mem"
               cpu: "limit_cpu"
            env:
            - name: BACKEND_HOST
               value: oppv-env_name-node:3000

Tệp Yaml của Dịch vụ Frontend

apiVersion: v1
kind: Service
metadata:
   name: appname
   labels:
      k8s-app: appname
spec:
   type: NodePort
   ports:
   - name: http
      port: 3000
      protocol: TCP
      targetPort: 3000
   selector:
      k8s-app: appname
      component: nodejs
      env: dev

Trình điều khiển bản sao Frontend Tệp Yaml

apiVersion: v1
kind: ReplicationController
metadata:
   name: Frontend
spec:
   replicas: 3
   template:
      metadata:
         name: frontend
         labels:
            k8s-app: Frontend
            component: nodejs
            env: Dev
spec:
   nodeSelector:
      resource-group: oppv
   containers:
      - name: appname
         image: IMAGE_TEMPLATE
         imagePullPolicy: Always
         ports:
            - containerPort: 3000
            resources:
               requests:
                  memory: "request_mem"
                  cpu: "limit_cpu"
                  limits:
                  memory: "limit_mem"
                  cpu: "limit_cpu"
            env:
               - name: ENV
               valueFrom:
               configMapKeyRef:
               name: appname
               key: config-env

Dịch vụ phụ trợ Tệp Yaml

apiVersion: v1
kind: Service
metadata:
   name: backend
   labels:
      k8s-app: backend
spec:
   type: NodePort
   ports:
   - name: http
      port: 9010
      protocol: TCP
      targetPort: 9000
   selector:
      k8s-app: appname
      component: play
      env: dev

Bộ điều khiển nhân bản sao lưu Tệp Yaml

apiVersion: v1
kind: ReplicationController
metadata:
   name: backend
spec:
   replicas: 3
   template:
      metadata:
         name: backend
      labels:
         k8s-app: beckend
         component: play
         env: dev
spec:
   nodeSelector:
      resource-group: oppv
      containers:
         - name: appname
            image: IMAGE_TEMPLATE
            imagePullPolicy: Always
            ports:
            - containerPort: 9000
            command: [ "./docker-entrypoint.sh" ]
            resources:
               requests:
                  memory: "request_mem"
                  cpu: "request_cpu"
               limits:
                  memory: "limit_mem"
                  cpu: "limit_cpu"
            volumeMounts:
               - name: config-volume
               mountPath: /app/vipin/play/conf
         volumes:
            - name: config-volume
            configMap:
            name: appname

Kubernetes – Tự động chia tỷ lệ (xem thêm)

The post Kubernetes – Tạo ứng dụng appeared first on Dongthoigian.net.

Các lệnh Kubectl được sử dụng để tương tác và quản lý các đối tượng Kubernetes và cụm. Trong chương này, chúng ta sẽ thảo luận về một số lệnh được sử dụng trong Kubernetes thông qua kubectl. kubectl annotate – Nó cập nhật chú thích trên một tài nguyên

$kubectl annotate [--overwrite] (-f FILENAME | TYPE NAME) KEY_1=VAL_1 ...
KEY_N = VAL_N [--resource-version = version]

Ví dụ,

kubectl annotate pods tomcat description = ‘my frontend’

kubectl api-version – Nó in các phiên bản API được hỗ trợ trên cụm.

$ kubectl api-version;

kubectl áp dụng – Nó có khả năng định cấu hình tài nguyên theo tệp hoặc stdin.

$ kubectl apply –f <filename>

kubectl đính kèm – Điều này đính kèm mọi thứ vào vùng chứa đang chạy.

$ kubectl attach <pod> –c <container>
$ kubectl attach 123456-7890 -c tomcat-conatiner

kubectl autoscale – Điều này được sử dụng để tự động chia tỷ lệ các nhóm được xác định như Triển khai, bộ bản sao, Bộ điều khiển nhân bản.

$ kubectl autoscale (-f FILENAME | TYPE NAME | TYPE/NAME) [--min = MINPODS] --
max = MAXPODS [--cpu-percent = CPU] [flags]
$ kubectl autoscale deployment foo --min = 2 --max = 10

kubectl cluster-info – Nó hiển thị Thông tin cụm.

$ kubectl cluster-info

kubectl cluster-info dump – Kết xuất thông tin liên quan đến cụm để gỡ lỗi và chẩn đoán.

$ kubectl cluster-info dump
$ kubectl cluster-info dump --output-directory = /path/to/cluster-state

kubectl config – Sửa đổi tệp kubeconfig.

$ kubectl config <SUBCOMMAD>
$ kubectl config –-kubeconfig <String of File name>

kubectl config current-context – Nó hiển thị ngữ cảnh hiện tại.

$ kubectl config current-context
#deploys the current context

kubectl config delete-cluster – Xóa cụm được chỉ định khỏi kubeconfig.

$ kubectl config delete-cluster <Cluster Name>

kubectl config delete-context – Xóa ngữ cảnh được chỉ định khỏi kubeconfig.

$ kubectl config delete-context <Context Name>

kubectl config get-cluster – Hiển thị cụm được xác định trong kubeconfig.

$ kubectl config get-cluster

$ kubectl config get-cluster <Cluser Name>

kubectl config get-context – Mô tả một hoặc nhiều ngữ cảnh.

$ kubectl config get-context <Context Name>kubectl config set-cluster – Đặt mục nhập cụm trong Kubernetes.

$ kubectl config set-cluster NAME [--server = server] [--certificateauthority =
path/to/certificate/authority] [--insecure-skip-tls-verify = true]

kubectl config set-context – Đặt một mục ngữ cảnh trong điểm nhập kubernetes

$ kubectl config set-context NAME [--cluster = cluster_nickname] [--
user = user_nickname] [--namespace = namespace]
$ kubectl config set-context prod –user = vipin-mishra

kubectl config set-credentials – Đặt mục nhập người dùng trong kubeconfig.

$ kubectl config set-credentials cluster-admin --username = vipin --
password = uXFGweU9l35qcif

kubectl config set – Đặt một giá trị riêng lẻ trong tệp kubeconfig.

$ kubectl config set PROPERTY_NAME PROPERTY_VALUE

kubectl config unset – Nó bỏ thiết lập một thành phần cụ thể trong kubectl.

$ kubectl config unset PROPERTY_NAME PROPERTY_VALUE

kubectl config use-context – Đặt bối cảnh hiện tại trong tệp kubectl.

$ kubectl config use-context <Context Name>

chế độ xem cấu hình kubectl

$ kubectl config view
$ kubectl config view –o jsonpath='{.users[?(@.name == "e2e")].user.password}'

kubectl cp – Sao chép tệp và thư mục đến và đi từ vùng chứa.

$ kubectl cp <Files from source> <Files to Destinatiion>
$ kubectl cp /tmp/foo <some-pod>:/tmp/bar -c <specific-container>

kubectl create – Để tạo tài nguyên theo tên tệp của hoặc stdin. Để làm điều này, các định dạng JSON hoặc YAML được chấp nhận.

$ kubectl create –f <File Name>
$ cat <file name> | kubectl create –f -

Theo cách tương tự, chúng ta có thể tạo nhiều thứ như được liệt kê bằng cách sử dụng lệnh create cùng với kubectl .

• triển khai
• không gian tên
• hạn ngạch
• docker-registry bí mật
• bí mật
• bí mật chung chung
• tls bí mật
• tài khoản dịch vụ
• nhóm dịch vụ
• bộ cân bằng dịch vụ
• dịch vụ gật đầu

kubectl delete – Xóa tài nguyên theo tên tệp, stdin, tài nguyên và tên.

$ kubectl delete –f ([-f FILENAME] | TYPE [(NAME | -l label | --all)])

kubectl description – Mô tả bất kỳ tài nguyên cụ thể nào trong kubernetes. Hiển thị chi tiết của tài nguyên hoặc một nhóm tài nguyên.

$ kubectl describe <type> <type name>
$ kubectl describe pod tomcat

cống kubectl – Điều này được sử dụng để thoát một nút cho mục đích bảo trì. Nó chuẩn bị cho nút để bảo trì. Thao tác này sẽ đánh dấu nút là không khả dụng để nó không được gán với một vùng chứa mới sẽ được tạo.

$ kubectl drain tomcat –force

kubectl chỉnh sửa – Nó được sử dụng để kết thúc tài nguyên trên máy chủ. Điều này cho phép chỉnh sửa trực tiếp tài nguyên mà người ta có thể nhận được thông qua công cụ dòng lệnh.

$ kubectl edit <Resource/Name | File Name)

Ex.

$ kubectl edit rc/tomcat

kubectl execute – Điều này giúp thực thi một lệnh trong vùng chứa.

$ kubectl exec POD <-c CONTAINER > — COMMAND < args…>

$ kubectl exec tomcat 123-5-456 date

kubectl exposure – Điều này được sử dụng để hiển thị các đối tượng Kubernetes như pod, bộ điều khiển sao chép và dịch vụ như một dịch vụ Kubernetes mới. Điều này có khả năng hiển thị nó qua một vùng chứa đang chạy hoặc từ một tệp yaml .

$ kubectl expose (-f FILENAME | TYPE NAME) [--port=port] [--protocol = TCP|UDP]
[--target-port = number-or-name] [--name = name] [--external-ip = external-ip-ofservice]
[--type = type]
$ kubectl expose rc tomcat –-port=80 –target-port = 30000
$ kubectl expose –f tomcat.yaml –port = 80 –target-port =

kubectl get – Lệnh này có khả năng tìm nạp dữ liệu trên cụm về các tài nguyên Kubernetes.

$ kubectl get [(-o|--output=)json|yaml|wide|custom-columns=...|custom-columnsfile=...|
go-template=...|go-template-file=...|jsonpath=...|jsonpath-file=...]
(TYPE [NAME | -l label] | TYPE/NAME ...) [flags]

Ví dụ,

$ kubectl get pod <pod name>
$ kubectl get service <Service name>

nhật ký kubectl – Chúng được sử dụng để lấy nhật ký của vùng chứa trong một nhóm. Việc in nhật ký có thể xác định tên vùng chứa trong nhóm. Nếu POD chỉ có một vùng chứa thì không cần xác định tên của nó.

$ kubectl logs [-f] [-p] POD [-c CONTAINER]
Example
$ kubectl logs tomcat.
$ kubectl logs –p –c tomcat.8

kubectl port-forward – Chúng được sử dụng để chuyển tiếp một hoặc nhiều cổng cục bộ tới nhóm.

$ kubectl port-forward POD [LOCAL_PORT:]REMOTE_PORT
[...[LOCAL_PORT_N:]REMOTE_PORT_N]
$ kubectl port-forward tomcat 3000 4000
$ kubectl port-forward tomcat 3000:5000

kubectl Replace – Có khả năng thay thế tài nguyên bằng tên tệp hoặc stdin .

$ kubectl replace -f FILENAME
$ kubectl replace –f tomcat.yml
$ cat tomcat.yml | kubectl replace –f -

kubectl roll-update – Thực hiện cập nhật liên tục trên bộ điều khiển nhân rộng. Thay thế bộ điều khiển sao chép được chỉ định bằng một bộ điều khiển sao chép mới bằng cách cập nhật POD tại một thời điểm.

$ kubectl rolling-update OLD_CONTROLLER_NAME ([NEW_CONTROLLER_NAME] --
image = NEW_CONTAINER_IMAGE | -f NEW_CONTROLLER_SPEC)
$ kubectl rolling-update frontend-v1 –f freontend-v2.yaml

triển khai kubectl – Nó có khả năng quản lý quá trình triển khai.

$ Kubectl rollout <Sub Command>
$ kubectl rollout undo deployment/tomcat

Ngoài những điều trên, chúng tôi có thể thực hiện nhiều tác vụ bằng cách sử dụng bản giới thiệu, chẳng hạn như:

• lịch sử phát hành
• tạm dừng triển khai
• bản tiếp tục triển khai
• tình trạng phát hành
• hoàn tác triển khai

kubectl run – Lệnh Run có khả năng chạy một hình ảnh trên Kubernetes cluster.

$ kubectl run NAME --image = image [--env = "key = value"] [--port = port] [--
replicas = replicas] [--dry-run = bool] [--overrides = inline-json] [--command] --
[COMMAND] [args...]
$ kubectl run tomcat --image = tomcat:7.0
$ kubectl run tomcat –-image = tomcat:7.0 –port = 5000

kubectl scale – Nó sẽ chia tỷ lệ kích thước của Kubernetes Deployments, ReplicaSet, Replication Controller hoặc job.

$ kubectl scale [--resource-version = version] [--current-replicas = count] --
replicas = COUNT (-f FILENAME | TYPE NAME )
$ kubectl scale –-replica = 3 rs/tomcat
$ kubectl scale –replica = 3 tomcat.yaml

hình ảnh bộ kubectl – Nó cập nhật hình ảnh của một mẫu nhóm.

$ kubectl set image (-f FILENAME | TYPE NAME)
CONTAINER_NAME_1 = CONTAINER_IMAGE_1 ... CONTAINER_NAME_N = CONTAINER_IMAGE_N
$ kubectl set image deployment/tomcat busybox = busybox ngnix = ngnix:1.9.1
$ kubectl set image deployments, rc tomcat = tomcat6.0 --all

kubectl đặt tài nguyên – Nó được sử dụng để thiết lập nội dung của tài nguyên. Nó cập nhật tài nguyên / giới hạn trên đối tượng với mẫu nhóm.

$ kubectl set resources (-f FILENAME | TYPE NAME) ([--limits = LIMITS & --
requests = REQUESTS]
$ kubectl set resources deployment tomcat -c = tomcat --
limits = cpu = 200m,memory = 512Mi

nút trên cùng kubectl – Nó hiển thị mức sử dụng CPU / Bộ nhớ / Bộ nhớ. Lệnh trên cùng cho phép bạn xem mức tiêu thụ tài nguyên cho các nút.

$ kubectl top node [node Name]

Lệnh tương tự cũng có thể được sử dụng với một nhóm.

Kubernetes – Tạo ứng dụng (xem thêm

The post Kubernetes – Lệnh Kubectl appeared first on Dongthoigian.net.

kind: Namespace
apiVersion: v1
metadata:
   annotations:
      net.beta.kubernetes.io/network-policy: |
      {
         "ingress": 
         {
            "isolation": "DefaultDeny"
         }
      }
$ kubectl annotate ns <namespace> "net.beta.kubernetes.io/network-policy = 
{\"ingress\": {\"isolation\": \"DefaultDeny\"}}"

Khi không gian tên được tạo, chúng ta cần tạo Chính sách mạng.

Chính sách mạng Yaml

kind: NetworkPolicy
apiVersion: extensions/v1beta1
metadata:
   name: allow-frontend
   namespace: myns
spec:
   podSelector:
      matchLabels:
         role: backend
   ingress:
   - from:
      - podSelector:
         matchLabels:
            role: frontend
   ports:
      - protocol: TCP
         port: 6379

Kubernetes – API

Kubernetes API đóng vai trò là nền tảng cho lược đồ cấu hình khai báo cho hệ thống. Công cụ dòng lệnh Kubectl có thể được sử dụng để tạo, cập nhật, xóa và lấy đối tượng API. Kubernetes API đóng vai trò giao tiếp giữa các thành phần khác nhau của Kubernetes.

Thêm API vào Kubernetes

Việc thêm một API mới vào Kubernetes sẽ bổ sung thêm các tính năng mới cho Kubernetes, điều này sẽ làm tăng chức năng của Kubernetes. Tuy nhiên, bên cạnh đó nó cũng sẽ làm tăng chi phí và khả năng bảo trì của hệ thống. Để tạo ra sự cân bằng giữa chi phí và độ phức tạp, có một số bộ được xác định cho nó.

API đang được thêm vào sẽ hữu ích cho hơn 50% người dùng. Không có cách nào khác để triển khai chức năng trong Kubernetes. Các trường hợp ngoại lệ được thảo luận trong cuộc họp cộng đồng của Kubernetes, và sau đó API được thêm vào.

Thay đổi API

Để tăng khả năng của Kubernetes, các thay đổi liên tục được đưa vào hệ thống. Nhóm Kubernetes thực hiện để thêm chức năng vào Kubernetes mà không xóa hoặc ảnh hưởng đến chức năng hiện có của hệ thống.

Để chứng minh quy trình chung, đây là một ví dụ (giả định) –

• Người dùng ĐĂNG một đối tượng Pod lên / api / v7beta1 / …
• JSON không được quản lý thành cấu trúc v7beta1.Pod
• Giá trị mặc định được áp dụng cho v7beta1.Pod
• V7beta1.Pod được chuyển đổi thành cấu trúc api.Pod
• Api.Pod được xác thực và mọi lỗi sẽ được trả lại cho người dùng
• Api.Pod được chuyển đổi thành v6.Pod (vì v6 là phiên bản ổn định mới nhất)
• V6.Pod được sắp xếp thành JSON và được ghi vào etcd

Bây giờ chúng ta đã lưu trữ đối tượng Pod, người dùng có thể NHẬN đối tượng đó trong bất kỳ phiên bản API nào được hỗ trợ. Ví dụ –

• Người dùng NHẬN Pod từ / api / v5 / …
• JSON được đọc từ etcd và không được quản lý thành cấu trúc v6.Pod
• Giá trị mặc định được áp dụng cho v6.Pod
• V6.Pod được chuyển đổi thành cấu trúc api.Pod
• Api.Pod được chuyển đổi thành cấu trúc v5.Pod
• V5.Pod được sắp xếp thành JSON và được gửi đến người dùng

Hàm ý của quá trình này là các thay đổi API phải được thực hiện cẩn thận và tương thích ngược.

Phiên bản API

Để hỗ trợ nhiều cấu trúc dễ dàng hơn, Kubernetes hỗ trợ nhiều phiên bản API, mỗi phiên bản API khác nhau tại các đường dẫn API khác nhau, chẳng hạn như / api / v1 hoặc / apsi / extensions / v1beta1

Các tiêu chuẩn lập phiên bản tại Kubernetes được xác định theo nhiều tiêu chuẩn.

Cấp độ Alpha

• Phiên bản này chứa alpha (ví dụ: v1alpha1)
• Phiên bản này có thể có lỗi; phiên bản đã kích hoạt có thể có lỗi
• Hỗ trợ cho lỗi có thể bị loại bỏ bất kỳ lúc nào.
• Chỉ được khuyến nghị sử dụng trong thử nghiệm ngắn hạn vì hỗ trợ có thể không có mặt mọi lúc.

Cấp độ Beta

• Tên phiên bản chứa beta (ví dụ: v2beta3)
• Mã được kiểm tra đầy đủ và phiên bản được kích hoạt được cho là ổn định.
• Hỗ trợ của tính năng sẽ không bị bỏ; có thể có một số thay đổi nhỏ.
• Chỉ được đề xuất cho các mục đích sử dụng không quan trọng trong kinh doanh vì khả năng xảy ra các thay đổi không tương thích trong các bản phát hành tiếp theo.

Mức độ ổn định

• Tên phiên bản là vX trong đó X là một số nguyên.

Phiên bản ổn định của các tính năng sẽ xuất hiện trong phần mềm đã phát hành cho nhiều phiên bản tiếp theo.

Kubernetes – Kubectl

Kubectl là tiện ích dòng lệnh để tương tác với Kubernetes API. Nó là một giao diện được sử dụng để giao tiếp và quản lý các nhóm trong Kubernetes cluster.

Người ta cần thiết lập kubectl thành cục bộ để tương tác với Kubernetes cluster.

Đặt Kubectl

Tải tệp thực thi xuống máy trạm cục bộ bằng lệnh curl.Trên Linux

$ curl -O https://storage.googleapis.com/kubernetesrelease/
release/v1.5.2/bin/linux/amd64/kubectl

Trên máy trạm OS X

$ curl -O https://storage.googleapis.com/kubernetesrelease/
release/v1.5.2/bin/darwin/amd64/kubectl

Sau khi quá trình tải xuống hoàn tất, hãy di chuyển các tệp nhị phân trong đường dẫn của hệ thống

$ chmod +x kubectl
$ mv kubectl /usr/local/bin/kubect

Định cấu hình Kubectl

Sau đây là các bước để thực hiện thao tác cấu hình.

$ kubectl config set-cluster default-cluster --server = https://${MASTER_HOST} --
certificate-authority = ${CA_CERT}

$ kubectl config set-credentials default-admin --certificateauthority = ${
CA_CERT} --client-key = ${ADMIN_KEY} --clientcertificate = ${
ADMIN_CERT}

$ kubectl config set-context default-system --cluster = default-cluster --
user = default-admin
$ kubectl config use-context default-system

• Thay thế $ {MASTER_HOST} bằng địa chỉ hoặc tên nút chính được sử dụng trong các bước trước.
• Thay thế $ {CA_CERT} bằng đường dẫn tuyệt đối đến ca.pem đã tạo ở các bước trước.
• Thay thế $ {ADMIN_KEY} bằng đường dẫn tuyệt đối đến admin-key.pem đã tạo ở các bước trước.
• Thay thế $ {ADMIN_CERT} bằng đường dẫn tuyệt đối đến admin.pem đã tạo ở các bước trước.

Xác minh thiết lập

Để xác minh xem kubectl có hoạt động tốt hay không, hãy kiểm tra xem ứng dụng Kubernetes có được thiết lập chính xác hay không

$ kubectl get nodes

NAME       LABELS                                     STATUS
Vipin.com  Kubernetes.io/hostname = vipin.mishra.com    Ready

Kubernetes – Lệnh Kubectl (xem thêm)

The post Kubernetes – Chính sách mạng appeared first on Dongthoigian.net.

Khái niệm về khối lượng đã xuất hiện với Docker, tuy nhiên vấn đề duy nhất là khối lượng bị giới hạn rất nhiều trong một nhóm cụ thể. Ngay sau khi vòng đời của một pod kết thúc, khối lượng cũng bị mất.

Mặt khác, các tập được tạo thông qua Kubernetes không bị giới hạn ở bất kỳ vùng chứa nào. Nó hỗ trợ bất kỳ hoặc tất cả các vùng chứa được triển khai bên trong nhóm Kubernetes. Một ưu điểm chính của tập Kubernetes là, nó hỗ trợ các loại lưu trữ khác nhau, trong đó nhóm có thể sử dụng nhiều trong số chúng cùng một lúc.

Các loại Khối lượng Kubernetes

Đây là danh sách một số tập Kubernetes phổ biến –

• voidDir – Đây là một loại ổ đĩa được tạo khi một Pod được gán cho một Node lần đầu tiên. Nó vẫn hoạt động miễn là Pod đang chạy trên nút đó. Ổ đĩa ban đầu trống và các vùng chứa trong nhóm có thể đọc và ghi các tệp trong ổ đĩa trống. Khi Pod bị xóa khỏi nút, dữ liệu trong voidDir sẽ bị xóa.
• hostPath – Loại ổ này gắn một tệp hoặc thư mục từ hệ thống tệp của nút máy chủ vào nhóm của bạn.
• gcePersualityDisk – Loại ổ đĩa này gắn một Đĩa cố định của Google Compute Engine (GCE) vào Pod của bạn. Dữ liệu trong gcePersistingDisk vẫn nguyên vẹn khi Pod bị xóa khỏi nút.
• awsElasticBlockStore – Loại ổ đĩa này gắn một Kho lưu trữ khối đàn hồi Amazon Web Services (AWS) vào Pod của bạn. Cũng giống như gcePersentlyDisk , dữ liệu trong awsElasticBlockStore vẫn nguyên vẹn khi Pod bị xóa khỏi nút.
• nfs – Ổ đĩa nfs cho phép một NFS (Hệ thống Tệp Mạng) hiện có được gắn vào nhóm của bạn. Dữ liệu trong tập nfs không bị xóa khi Pod bị xóa khỏi nút. Âm lượng chỉ được tháo lắp.
• iscsi – Ổ đĩa iscsi cho phép ổ đĩa iSCSI (SCSI qua IP) hiện có được gắn vào nhóm của bạn.
• florit – Nó là một trình quản lý khối lượng dữ liệu vùng chứa được phân cụm mã nguồn mở. Nó được sử dụng để quản lý khối lượng dữ liệu. Một khối lượng bộ sưu tập cho phép tập dữ liệu Flocker được gắn vào một nhóm. Nếu tập dữ liệu không tồn tại trong Flocker, thì trước tiên bạn cần tạo nó bằng cách sử dụng API Flocker.
• glusterfs – Glusterfs là một hệ thống tệp nối mạng mã nguồn mở. Một volume glusterfs cho phép gắn volume glusterfs vào nhóm của bạn.
• rbd – RBD là viết tắt của Rados Block Device. Ổ đĩa rbd cho phép gắn ổ đĩa Thiết bị chặn Rados vào nhóm của bạn. Dữ liệu vẫn được bảo toàn sau khi Pod bị xóa khỏi nút.
• cephfs – Ổ đĩa cephfs cho phép ổ đĩa CephFS hiện có được gắn vào nhóm của bạn. Dữ liệu vẫn còn nguyên vẹn sau khi Pod bị xóa khỏi nút.
• gitRepo – Ổ đĩa gitRepo gắn một thư mục trống và sao chép kho lưu trữ git vào đó để pod của bạn sử dụng.
• bí mật – Một ổ đĩa bí mật được sử dụng để chuyển thông tin nhạy cảm, chẳng hạn như mật khẩu, đến nhóm.
• Kiên trì _ _ PersentlyVolumes là một cách để người dùng “yêu cầu” dung lượng lưu trữ lâu bền (chẳng hạn như GCE PersentlyDisk hoặc một ổ iSCSI) mà không cần biết chi tiết về môi trường đám mây cụ thể.
• downwardAPI – Khối lượngAPI hướng xuống được sử dụng để cung cấp dữ liệu API hướng xuống cho các ứng dụng. Nó gắn một thư mục và ghi dữ liệu được yêu cầu vào các tệp văn bản thuần túy.
• azureDiskVolume – AzureDiskVolume được sử dụng để gắn Đĩa dữ liệu Microsoft Azure vào một Pod.

Yêu cầu về số lượng liên tục và số lượng liên tục

Ổ đĩa liên tục (PV) – Đó là một phần lưu trữ mạng đã được cấp phép bởi quản trị viên. Đó là một tài nguyên trong cụm độc lập với bất kỳ nhóm riêng lẻ nào sử dụng PV.

Khiếu nại về khối lượng liên tục (PVC) – Bộ lưu trữ mà Kubernetes yêu cầu cho các vỏ của nó được gọi là PVC. Người dùng không cần biết việc cung cấp cơ bản. Các xác nhận quyền sở hữu phải được tạo trong cùng một không gian tên nơi nhóm được tạo.Tạo khối lượng liên tục

kind: PersistentVolume ---------> 1
apiVersion: v1
metadata:
   name: pv0001 ------------------> 2
   labels:
      type: local
spec:
   capacity: -----------------------> 3
      storage: 10Gi ----------------------> 4
   accessModes:
      - ReadWriteOnce -------------------> 5
      hostPath:
         path: "/tmp/data01" --------------------------> 6

Trong đoạn mã trên, chúng tôi đã xác định –

• loại: PersentlyVolume → Chúng tôi đã định nghĩa loại là PersentlyVolume cho kubernetes biết rằng tệp yaml đang được sử dụng để tạo Ổ cứng liên tục.
• name: pv0001 → Tên của PersualityVolume mà chúng ta đang tạo.
• công suất: → Thông số này sẽ xác định công suất của PV mà chúng tôi đang cố gắng tạo ra.
• lưu trữ: 10Gi → Điều này cho cơ sở hạ tầng bên dưới biết rằng chúng tôi đang cố gắng xác nhận không gian 10Gi trên đường dẫn đã xác định.
• ReadWriteOnce → Điều này cho biết quyền truy cập của ổ đĩa mà chúng tôi đang tạo.

path: “/ tmp / data01” → Định nghĩa này cho máy biết rằng chúng tôi đang cố gắng tạo khối lượng theo đường dẫn này trên cơ sở hạ tầng bên dưới.

Tạo PV

$ kubectl create –f local-01.yaml
persistentvolume "pv0001" created

Kiểm tra PV

$ kubectl get pv
NAME        CAPACITY      ACCESSMODES       STATUS       CLAIM      REASON     AGE
pv0001        10Gi            RWO         Available                            14s

Mô tả PV

$ kubectl describe pv pv0001

Tạo xác nhận số lượng liên tục

kind: PersistentVolumeClaim --------------> 1
apiVersion: v1
metadata:
   name: myclaim-1 --------------------> 2
spec:
   accessModes:
      - ReadWriteOnce ------------------------> 3
   resources:
      requests:
         storage: 3Gi ---------------------> 4

Trong đoạn mã trên, chúng tôi đã xác định –

• loại: PersentlyVolumeClaim → Nó hướng dẫn cơ sở hạ tầng cơ bản mà chúng tôi đang cố gắng yêu cầu một lượng không gian cụ thể.
• name: myclaim-1 → Tên của xác nhận quyền sở hữu mà chúng tôi đang cố gắng tạo ra.
• ReadWriteOnce → Điều này chỉ định chế độ xác nhận quyền sở hữu mà chúng tôi đang cố gắng tạo.
• dung lượng lưu trữ: 3Gi → Điều này sẽ cho kubernetes biết về dung lượng mà chúng tôi đang cố gắng yêu cầu.

Tạo PVC

$ kubectl create –f myclaim-1
persistentvolumeclaim "myclaim-1" created

Nhận thông tin chi tiết về PVC

$ kubectl get pvc
NAME        STATUS   VOLUME   CAPACITY   ACCESSMODES   AGE
myclaim-1   Bound    pv0001     10Gi         RWO       7s

Mô tả PVC

$ kubectl describe pv pv0001

Sử dụng PV và PVC với POD

kind: Pod
apiVersion: v1
metadata:
   name: mypod
   labels:
      name: frontendhttp
spec:
   containers:
   - name: myfrontend
      image: nginx
      ports:
      - containerPort: 80
         name: "http-server"
      volumeMounts: ----------------------------> 1
      - mountPath: "/usr/share/tomcat/html"
         name: mypd
   volumes: -----------------------> 2
      - name: mypd
         persistentVolumeClaim: ------------------------->3
         claimName: myclaim-1

Trong đoạn mã trên, chúng tôi đã xác định –

• volumeMounts: → Đây là đường dẫn trong vùng chứa mà quá trình gắn sẽ diễn ra.
• Khối lượng: → Định nghĩa này xác định định nghĩa khối lượng mà chúng ta sẽ xác nhận.
• dai dẳngVolumeClaim: → Dưới đây, chúng tôi xác định tên ổ đĩa mà chúng tôi sẽ sử dụng trong nhóm đã xác định.

Kubernetes – Bí mật

Bí mật có thể được định nghĩa là các đối tượng Kubernetes được sử dụng để lưu trữ dữ liệu nhạy cảm như tên người dùng và mật khẩu có mã hóa.

Có nhiều cách để tạo ra bí mật trong Kubernetes.

• Tạo từ tệp txt.
• Tạo từ tệp yaml.

Tạo từ tệp văn bản

Để tạo bí mật từ tệp văn bản như tên người dùng và mật khẩu, trước tiên chúng ta cần lưu trữ chúng trong tệp txt và sử dụng lệnh sau.

$ kubectl create secret generic tomcat-passwd –-from-file = ./username.txt –fromfile = ./.
password.txt

Tạo từ tệp Yaml

apiVersion: v1
kind: Secret
metadata:
name: tomcat-pass
type: Opaque
data:
   password: <User Password>
   username: <User Name>

Tạo bí mật

$ kubectl create –f Secret.yaml
secrets/tomcat-pass

Sử dụng bí mật

Khi chúng tôi đã tạo ra các bí mật, nó có thể được sử dụng trong một nhóm hoặc bộ điều khiển sao chép dưới dạng:

• Biến môi trường
• Âm lượng

Như môi trường biến

Để sử dụng bí mật làm biến môi trường, chúng ta sẽ sử dụng env trong phần spec của tệp pod yaml.

env:
- name: SECRET_USERNAME
   valueFrom:
      secretKeyRef:
         name: mysecret
         key: tomcat-pass

Như âm lượng

spec:
   volumes:
      - name: "secretstest"
         secret:
            secretName: tomcat-pass
   containers:
      - image: tomcat:7.0
         name: awebserver
         volumeMounts:
            - mountPath: "/tmp/mysec"
            name: "secretstest"

Cấu hình bí mật làm biến môi trường

apiVersion: v1
kind: ReplicationController
metadata:
   name: appname
spec:
replicas: replica_count
template:
   metadata:
      name: appname
   spec:
      nodeSelector:
         resource-group:
      containers:
         - name: appname
            image:
            imagePullPolicy: Always
            ports:
            - containerPort: 3000
            env: -----------------------------> 1
               - name: ENV
                  valueFrom:
                     configMapKeyRef:
                        name: appname
                        key: tomcat-secrets

Trong đoạn mã trên, theo định nghĩa env , chúng ta đang sử dụng các bí mật làm biến môi trường trong bộ điều khiển sao chép.

Secrets As Volume Mount

apiVersion: v1
kind: pod
metadata:
   name: appname
spec:
   metadata:
      name: appname
   spec:
   volumes:
      - name: "secretstest"
         secret:
            secretName: tomcat-pass
   containers:
      - image: tomcat: 8.0
         name: awebserver
         volumeMounts:
            - mountPath: "/tmp/mysec"
            name: "secretstest"

Kubernetes – Chính sách mạng (xem thêm)

The post Kubernetes – Tệp appeared first on Dongthoigian.net.

Cách tốt nhất là sử dụng bộ điều khiển nhân bản để quản lý vòng đời của nhóm thay vì tạo nhóm lặp đi lặp lại.

apiVersion: v1
kind: ReplicationController --------------------------> 1
metadata:
   name: Tomcat-ReplicationController --------------------------> 2
spec:
   replicas: 3 ------------------------> 3
   template:
      metadata:
         name: Tomcat-ReplicationController
      labels:
         app: App
         component: neo4j
      spec:
         containers:
         - name: Tomcat- -----------------------> 4
         image: tomcat: 8.0
         ports:
            - containerPort: 7474 ------------------------> 5

Chi tiết thiết lập

• Loại: ReplicationController → Trong đoạn mã trên, chúng ta đã định nghĩa loại là bộ điều khiển sao chép để cho kubectl biết rằng tệp yaml sẽ được sử dụng để tạo bộ điều khiển sao chép.
• tên: Tomcat-ReplicationController → Điều này giúp xác định tên mà bộ điều khiển nhân bản sẽ được tạo. Nếu chúng ta chạy kubctl, lấy rc <Tomcat-ReplicationController> , nó sẽ hiển thị chi tiết bộ điều khiển sao chép.
• bản sao: 3 → Điều này giúp bộ điều khiển nhân bản hiểu rằng nó cần duy trì ba bản sao của một nhóm tại bất kỳ thời điểm nào trong vòng đời của nhóm.
• name: Tomcat → Trong phần thông số kỹ thuật, chúng ta đã định nghĩa tên là tomcat, tên này sẽ cho bộ điều khiển nhân bản biết rằng vùng chứa hiện diện bên trong các pod là tomcat.

containerPort: 7474 → Nó giúp đảm bảo rằng tất cả các nút trong cụm nơi nhóm đang chạy vùng chứa bên trong nhóm sẽ được hiển thị trên cùng một cổng 7474.

Ở đây, dịch vụ Kubernetes đang hoạt động như một bộ cân bằng tải cho ba bản sao tomcat.

Kubernetes – Bộ bản sao

Replica Set đảm bảo có bao nhiêu bản sao của nhóm sẽ được chạy. Nó có thể được coi là một sự thay thế của bộ điều khiển nhân rộng. Sự khác biệt chính giữa bộ bản sao và bộ điều khiển sao chép là, bộ điều khiển sao chép chỉ hỗ trợ bộ chọn dựa trên bình đẳng trong khi bộ bản sao hỗ trợ bộ chọn dựa trên bộ.

apiVersion: extensions/v1beta1 --------------------->1
kind: ReplicaSet --------------------------> 2
metadata:
   name: Tomcat-ReplicaSet
spec:
   replicas: 3
   selector:
      matchLables:
         tier: Backend ------------------> 3
      matchExpression:
{ key: tier, operation: In, values: [Backend]} --------------> 4
template:
   metadata:
      lables:
         app: Tomcat-ReplicaSet
         tier: Backend
      labels:
         app: App
         component: neo4j
   spec:
      containers:
      - name: Tomcat
      image: tomcat: 8.0
      ports:
      - containerPort: 7474

Chi tiết thiết lập

• apiVersion: extensions / v1beta1 → Trong đoạn mã trên, phiên bản API là phiên bản beta nâng cao của Kubernetes hỗ trợ khái niệm tập hợp bản sao.
• kind: ReplicaSet → Chúng tôi đã định nghĩa loại là tập hợp bản sao giúp kubectl hiểu rằng tệp được sử dụng để tạo tập hợp bản sao.
• tier: Backend → Chúng tôi đã định nghĩa lớp nhãn là backend tạo ra một bộ chọn phù hợp.
• {key: tier, operation: In, values: [Backend]} → Điều này sẽ giúp matchExpression hiểu điều kiện đối sánh mà chúng ta đã xác định và trong phép toán được matchlabel sử dụng để tìm chi tiết.

Chạy tệp ở trên bằng cách sử dụng kubectl và tạo bộ bản sao phụ trợ với định nghĩa được cung cấp trong tệp yaml .

Kubernetes – Triển khai

Các triển khai được nâng cấp và phiên bản cao hơn của bộ điều khiển nhân rộng. Họ quản lý việc triển khai các bộ bản sao cũng là một phiên bản nâng cấp của bộ điều khiển sao chép. Họ có khả năng cập nhật tập hợp bản sao và cũng có khả năng quay trở lại phiên bản trước đó.

Họ cung cấp nhiều tính năng cập nhật của MatchLabels và bộ chọn . Chúng tôi đã có một bộ điều khiển mới trong Kubernetes master được gọi là bộ điều khiển triển khai, điều này làm cho nó xảy ra. Nó có khả năng thay đổi việc triển khai giữa chừng.

Thay đổi triển khai

Đang cập nhật – Người dùng có thể cập nhật triển khai đang diễn ra trước khi hoàn thành. Trong trường hợp này, triển khai hiện có sẽ được giải quyết và triển khai mới sẽ được tạo.

Xóa – Người dùng có thể tạm dừng / hủy bỏ việc triển khai bằng cách xóa nó trước khi hoàn tất. Việc tạo lại cùng một triển khai sẽ tiếp tục.

Khôi phục – Chúng tôi có thể khôi phục việc triển khai hoặc quá trình triển khai đang diễn ra. Người dùng có thể tạo hoặc cập nhật triển khai bằng cách sử dụng DeploymentSpec.PodTemplateSpec = oldRC.PodTemplateSpec.

Chiến lược triển khai

Các chiến lược triển khai giúp xác định cách RC mới nên thay thế RC hiện tại.

Tái tạo – Tính năng này sẽ giết tất cả RC hiện có và sau đó hiển thị những cái mới. Điều này dẫn đến việc triển khai nhanh chóng, tuy nhiên nó sẽ dẫn đến thời gian ngừng hoạt động khi các nhóm cũ không hoạt động và các nhóm mới không xuất hiện.

Rolling Update – Tính năng này dần dần loại bỏ RC cũ và đưa lên RC mới. Điều này dẫn đến việc triển khai chậm, tuy nhiên không có triển khai. Luôn luôn có sẵn một số nhóm cũ và một số nhóm mới trong quá trình này. Tệp cấu hình của Deployment trông như thế này.

apiVersion: extensions/v1beta1 --------------------->1
kind: Deployment --------------------------> 2
metadata:
   name: Tomcat-ReplicaSet
spec:
   replicas: 3
   template:
      metadata:
         lables:
            app: Tomcat-ReplicaSet
            tier: Backend
   spec:
      containers:
         - name: Tomcatimage:
            tomcat: 8.0
            ports:
               - containerPort: 7474

Trong đoạn mã trên, điều duy nhất khác với bộ bản sao là chúng ta đã định nghĩa loại là triển khai.

Tạo triển khai

$ kubectl create –f Deployment.yaml -–record
deployment "Deployment" created Successfully.

Tìm nạp triển khai

$ kubectl get deployments
NAME           DESIRED     CURRENT     UP-TO-DATE     AVILABLE    AGE
Deployment        3           3           3              3        20s

Kiểm tra trạng thái triển khai

$ kubectl rollout status deployment/Deployment

Cập nhật triển khai

$ kubectl set image deployment/Deployment tomcat=tomcat:6.0

Quay lại triển khai trước đó

$ kubectl rollout undo deployment/Deployment –to-revision=2

Kubernetes – Tệp (xem thêm)

The post Kubernetes – Bộ điều khiển sao chép appeared first on Dongthoigian.net.

Nhãn là các cặp khóa-giá trị được gắn vào nhóm, bộ điều khiển sao chép và dịch vụ. Chúng được sử dụng làm thuộc tính xác định cho các đối tượng như nhóm và bộ điều khiển sao chép. Chúng có thể được thêm vào một đối tượng tại thời điểm tạo và có thể được thêm vào hoặc sửa đổi tại thời điểm chạy.

Bộ chọn

Nhãn không cung cấp tính duy nhất. Nói chung, chúng ta có thể nói nhiều đối tượng có thể mang các nhãn giống nhau. Bộ chọn nhãn là nguyên thủy phân nhóm cốt lõi trong Kubernetes. Chúng được người dùng sử dụng để chọn một tập hợp các đối tượng.

API Kubernetes hiện hỗ trợ hai loại bộ chọn –

• Bộ chọn dựa trên bình đẳng
• Bộ chọn dựa trên bộ

Bộ chọn dựa trên bình đẳng

Chúng cho phép lọc theo khóa và giá trị. Các đối tượng phù hợp phải đáp ứng tất cả các nhãn được chỉ định.

Bộ chọn dựa trên bộ

Bộ chọn dựa trên bộ cho phép lọc các khóa theo một bộ giá trị.

apiVersion: v1
kind: Service
metadata:
   name: sp-neo4j-standalone
spec:
   ports:
      - port: 7474
      name: neo4j
   type: NodePort
   selector:
      app: salesplatform ---------> 1
      component: neo4j -----------> 2

Trong đoạn mã trên, chúng tôi đang sử dụng bộ chọn nhãn làm ứng dụng: salesplatform và thành phần dưới dạng thành phần: neo4j .

Khi chúng tôi chạy tệp bằng lệnh kubectl , nó sẽ tạo một dịch vụ với tên sp-neo4j-standalone sẽ giao tiếp trên cổng 7474. Ype là NodePort với bộ chọn nhãn mới là ứng dụng: salesplatform và thành phần: neo4j .

Kubernetes – Không gian tên

Không gian tên cung cấp một tiêu chuẩn bổ sung cho tên tài nguyên. Điều này rất hữu ích khi nhiều nhóm đang sử dụng cùng một cụm và có khả năng xảy ra xung đột tên. Nó có thể như một bức tường ảo giữa nhiều cụm.

Chức năng của không gian tên

Sau đây là một số chức năng quan trọng của Không gian tên trong Kubernetes:

• Không gian tên giúp giao tiếp nhóm với nhóm bằng cách sử dụng cùng một không gian tên.
• Không gian tên là các cụm ảo có thể nằm trên cùng một cụm vật lý.
• Chúng cung cấp sự tách biệt hợp lý giữa các đội và môi trường của họ.

Tạo không gian tên

Lệnh sau được sử dụng để tạo một không gian tên.

apiVersion: v1
kind: Namespce
metadata
   name: elk

Kiểm soát không gian tên

Lệnh sau được sử dụng để kiểm soát không gian tên.

$ kubectl create –f namespace.yml ---------> 1
$ kubectl get namespace -----------------> 2
$ kubectl get namespace <Namespace name> ------->3
$ kubectl describe namespace <Namespace name> ---->4
$ kubectl delete namespace <Namespace name>

Trong đoạn mã trên,

• Chúng tôi đang sử dụng lệnh để tạo một không gian tên.
• Điều này sẽ liệt kê tất cả các không gian tên có sẵn.
• Thao tác này sẽ nhận được một không gian tên cụ thể có tên được chỉ định trong lệnh.
• Điều này sẽ mô tả chi tiết đầy đủ về dịch vụ.
• Thao tác này sẽ xóa một không gian tên cụ thể có trong cụm.

Sử dụng không gian tên trong dịch vụ – Ví dụ

Sau đây là một ví dụ về tệp mẫu để sử dụng không gian tên trong dịch vụ.

apiVersion: v1
kind: Service
metadata:
   name: elasticsearch
   namespace: elk
   labels:
      component: elasticsearch
spec:
   type: LoadBalancer
   selector:
      component: elasticsearch
   ports:
   - name: http
      port: 9200
      protocol: TCP
   - name: transport
      port: 9300
      protocol: TCP

Trong đoạn mã trên, chúng tôi đang sử dụng cùng một không gian tên trong siêu dữ liệu dịch vụ với tên của nai sừng tấm .

Kubernetes – Nút

Một nút là một máy làm việc trong cụm Kubernetes, nó còn được gọi là một tay sai. Chúng là các đơn vị làm việc có thể là vật lý, máy ảo hoặc một phiên bản đám mây.

Mỗi nút có tất cả cấu hình bắt buộc cần thiết để chạy một nhóm trên đó, chẳng hạn như dịch vụ proxy và dịch vụ kubelet cùng với Docker, được sử dụng để chạy các vùng chứa Docker trên nhóm được tạo trên nút.

Chúng không được tạo bởi Kubernetes mà được tạo ra bên ngoài bởi nhà cung cấp dịch vụ đám mây hoặc trình quản lý cụm Kubernetes trên máy vật lý hoặc máy ảo.

Thành phần quan trọng của Kubernetes để xử lý nhiều nút là trình quản lý bộ điều khiển, chạy nhiều loại bộ điều khiển để quản lý các nút. Để quản lý các nút, Kubernetes tạo một đối tượng thuộc loại nút này sẽ xác thực rằng đối tượng được tạo là một nút hợp lệ. Dịch vụ với Bộ chọn

apiVersion: v1
kind: node
metadata:
   name: < ip address of the node>
   labels:
      name: <lable name>

Ở định dạng JSON, đối tượng thực được tạo ra trông như sau:

{
   Kind: node
   apiVersion: v1
   "metadata": 
   {
      "name": "10.01.1.10",
      "labels"
      {
         "name": "cluster 1 node"
      }
   }
}

Bộ điều khiển nút

Chúng là tập hợp các dịch vụ chạy trong Kubernetes master và liên tục giám sát nút trong cụm trên cơ sở metadata.name. Nếu tất cả các dịch vụ được yêu cầu đang chạy, thì nút đó được xác thực và một nhóm mới được tạo sẽ được bộ điều khiển gán cho nút đó. Nếu nó không hợp lệ, thì master sẽ không gán bất kỳ nhóm nào cho nó và sẽ đợi cho đến khi nó trở nên hợp lệ.

Kubernetes master đăng ký nút tự động, nếu cờ –register-node là true.

–register-node = true

Tuy nhiên, nếu quản trị viên cụm muốn quản lý nó theo cách thủ công thì điều đó có thể được thực hiện bằng cách chuyển sang –

–register-node = false

Kubernetes – Dịch vụ

Một dịch vụ có thể được định nghĩa là một tập hợp các nhóm hợp lý. Nó có thể được định nghĩa là một phần trừu tượng trên đầu nhóm cung cấp một địa chỉ IP và tên DNS duy nhất mà các nhóm có thể được truy cập. Với Service, rất dễ dàng quản lý cấu hình cân bằng tải. Nó giúp các nhóm mở rộng quy mô rất dễ dàng.

Một dịch vụ là một đối tượng REST trong Kubernetes mà định nghĩa của nó có thể được đăng lên Kubernetes apiServer trên Kubernetes master để tạo một phiên bản mới.

Dịch vụ không có bộ chọn

apiVersion: v1
kind: Service
metadata:
   name: dongthoigian_net_service
spec:
   ports:
   - port: 8080
   targetPort: 31999

Cấu hình trên sẽ tạo một dịch vụ với tên dongthoigian_net_service

Tệp cấu hình dịch vụ với bộ chọn

apiVersion: v1
kind: Service
metadata:
   name: dongthoigian_net_service
spec:
   selector:
      application: "My Application" -------------------> (Selector)
   ports:
   - port: 8080
   targetPort: 31999

Trong ví dụ này, chúng ta có một bộ chọn; vì vậy để chuyển lưu lượng truy cập, chúng ta cần tạo một điểm cuối theo cách thủ công.

apiVersion: v1
kind: Endpoints
metadata:
   name: dongthoigian_net_service

subnets:
   address:
      "ip": "192.168.168.40" -------------------> (Selector)
   ports:
      - port: 8080

Trong đoạn mã trên, chúng tôi đã tạo một điểm cuối sẽ định tuyến lưu lượng đến điểm cuối được định nghĩa là “192.168.168.40:8080”. Tạo dịch vụ đa cổng

apiVersion: v1
kind: Service
metadata:
   name: dongthoigian_net_service
spec:
   selector:
      application: “My Application” -------------------> (Selector)
   ClusterIP: 10.3.0.12
   ports:
      -name: http
      protocol: TCP
      port: 80
      targetPort: 31999
   -name:https
      Protocol: TCP
      Port: 443
      targetPort: 31998

Các loại dịch vụ

ClusterIP – Điều này giúp hạn chế dịch vụ trong cụm. Nó cho thấy dịch vụ trong cụm Kubernetes đã xác định.

spec:
   type: NodePort
   ports:
   - port: 8080
      nodePort: 31999
      name: NodeportService

NodePort – Nó sẽ hiển thị dịch vụ trên một cổng tĩnh trên nút được triển khai. Dịch vụ ClusterIP , mà dịch vụ NodePort sẽ định tuyến, được tạo tự động. Dịch vụ có thể được truy cập từ bên ngoài cụm bằng NodeIP: nodePort .

spec:
   ports:
   - port: 8080
      nodePort: 31999
      name: NodeportService
      clusterIP: 10.20.30.40

Load Balancer – Nó sử dụng bộ cân bằng tải của các nhà cung cấp đám mây. Các dịch vụ NodePort và ClusterIP được tạo tự động mà bộ cân bằng tải bên ngoài sẽ định tuyến.

Tệp yaml dịch vụ đầy đủ với loại dịch vụ là Node Port. Cố gắng tạo một cái cho mình.

apiVersion: v1
kind: Service
metadata:
   name: appname
   labels:
      k8s-app: appname
spec:
   type: NodePort
   ports:
   - port: 8080
      nodePort: 31999
      name: omninginx
   selector:
      k8s-app: appname
      component: nginx
      env: env_name

Kubernetes – Pod

Một nhóm là một tập hợp các vùng chứa và bộ lưu trữ của nó bên trong một nút của một cụm Kubernetes. Có thể tạo một nhóm với nhiều vùng chứa bên trong nó. Ví dụ: giữ một vùng chứa cơ sở dữ liệu và vùng chứa dữ liệu trong cùng một nhóm.

Các loại Pod

Có hai loại Vỏ –

• Hộp chứa đơn
• Nhiều thùng chứa

Hộp chứa đơn

Chúng có thể được tạo đơn giản bằng lệnh kubctl run, nơi bạn có một hình ảnh được xác định trên sổ đăng ký Docker mà chúng tôi sẽ kéo trong khi tạo nhóm.

$ kubectl run <name of pod> --image=<name of the image from registry>

Ví dụ – Chúng tôi sẽ tạo một nhóm với hình ảnh tomcat có sẵn trên trung tâm Docker.

$ kubectl run tomcat --image = tomcat:8.0

Điều này cũng có thể được thực hiện bằng cách tạo tệp yaml và sau đó chạy lệnh tạo kubectl .

apiVersion: v1
kind: Pod
metadata:
   name: Tomcat
spec:
   containers:
   - name: Tomcat
    image: tomcat: 8.0
    ports:
containerPort: 7500
   imagePullPolicy: Always

Khi tệp yaml ở trên được tạo, chúng tôi sẽ lưu tệp với tên là tomcat.yml và chạy lệnh tạo để chạy tài liệu.

$ kubectl create –f tomcat.yml

Nó sẽ tạo một pod với tên là tomcat. Chúng ta có thể sử dụng lệnh description cùng với kubectl để mô tả nhóm.

Nhiều vùng chứa

Nhiều nhóm vùng chứa được tạo bằng cách sử dụng thư yaml với định nghĩa của các vùng chứa.

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

Trong đoạn mã trên, chúng ta đã tạo một nhóm với hai vùng chứa bên trong nó, một cho tomcat và một cho MongoDB.

Kubernetes – Bộ điều khiển sao chép (xem thêm)

The post Kubernetes – Nhãn & Bộ chọn appeared first on Dongthoigian.net.

Khi chúng ta đang định cấu hình một nhóm, thuộc tính hình ảnh trong tệp cấu hình có cùng cú pháp như lệnh Docker. Tệp cấu hình có một trường để xác định tên hình ảnh mà chúng tôi định lấy từ sổ đăng ký.

Sau đây là cấu trúc cấu hình chung sẽ kéo hình ảnh từ sổ đăng ký Docker và triển khai vào vùng chứa Kubernetes.

apiVersion: v1
kind: pod
metadata:
   name: Tesing_for_Image_pull -----------> 1
   spec:
      containers:
         - name: neo4j-server ------------------------> 2
         image: <Name of the Docker image>----------> 3
         imagePullPolicy: Always ------------->4
         command: ["echo", "SUCCESS"] ------------------->

Trong đoạn mã trên, chúng tôi đã xác định –

• name: Tesing_for_Image_pull – Tên này được đặt để xác định và kiểm tra tên của vùng chứa sẽ được tạo sau khi kéo hình ảnh từ sổ đăng ký Docker.
• name: neo4j-server – Đây là tên được đặt cho vùng chứa mà chúng tôi đang cố gắng tạo. Giống như chúng tôi đã cung cấp cho máy chủ neo4j.
• image: <Tên của hình ảnh Docker> – Đây là tên của hình ảnh mà chúng tôi đang cố gắng lấy từ Docker hoặc sổ đăng ký nội bộ của hình ảnh. Chúng tôi cần xác định một đường dẫn đăng ký hoàn chỉnh cùng với tên hình ảnh mà chúng tôi đang cố gắng kéo.
• imagePullPolicy – Luôn luôn – Chính sách kéo hình ảnh này xác định rằng bất cứ khi nào chúng tôi chạy tệp này để tạo vùng chứa, nó sẽ kéo lại cùng một tên.
• command: [“echo”, “SUCCESS”] – Với điều này, khi chúng ta tạo vùng chứa và nếu mọi thứ suôn sẻ, nó sẽ hiển thị thông báo khi chúng ta truy cập vùng chứa.

Để kéo hình ảnh và tạo vùng chứa, chúng ta sẽ chạy lệnh sau.

$ kubectl create –f Tesing_for_Image_pull

Sau khi chúng tôi tìm nạp nhật ký, chúng tôi sẽ nhận được kết quả là thành công

$ kubectl log Tesing_for_Image_pull

Lệnh trên sẽ tạo ra kết quả là thành công hoặc chúng ta sẽ nhận được kết quả là thất bại.Lưu ý – Bạn nên tự mình thử tất cả các lệnh.

Kubernetes – Việc làm

Chức năng chính của một công việc là tạo một hoặc nhiều nhóm và theo dõi sự thành công của các nhóm. Chúng đảm bảo rằng số lượng nhóm được chỉ định được hoàn thành thành công. Khi một số lần chạy nhóm thành công được chỉ định được hoàn thành, thì công việc được coi là hoàn thành.

Tạo công việc

Sử dụng lệnh sau để tạo một công việc:

apiVersion: v1
kind: Job ------------------------> 1
metadata:
   name: py
   spec:
   template:
      metadata
      name: py -------> 2
      spec:
         containers:
            - name: py ------------------------> 3
            image: python----------> 4
            command: ["python", "SUCCESS"]
            restartPocliy: Never --------> 5

Trong đoạn mã trên, chúng tôi đã xác định –

• loại: Công việc → Chúng tôi đã định nghĩa loại là Công việc sẽ cho kubectl biết rằng tệp yaml đang được sử dụng để tạo một nhóm loại công việc.
• Tên: py → Đây là tên của mẫu mà chúng tôi đang sử dụng và thông số xác định mẫu.
• name: py → chúng tôi đã đặt tên là py dưới thông số kỹ thuật của vùng chứa để giúp xác định Pod sẽ được tạo ra từ nó.
• Hình ảnh: python → hình ảnh mà chúng ta sẽ kéo để tạo vùng chứa sẽ chạy bên trong nhóm.
• restartPolicy: Never → Điều kiện khởi động lại hình ảnh này được đưa ra là không bao giờ có nghĩa là nếu vùng chứa bị hủy hoặc nếu nó là false, thì nó sẽ không tự khởi động lại.

Chúng tôi sẽ tạo công việc bằng cách sử dụng lệnh sau với yaml được lưu với tên py.yaml .

$ kubectl create –f py.yaml

Lệnh trên sẽ tạo một công việc. Nếu bạn muốn kiểm tra trạng thái của công việc, hãy sử dụng lệnh sau.

$ kubectl describe jobs/py

Lệnh trên sẽ tạo một công việc. Nếu bạn muốn kiểm tra trạng thái của công việc, hãy sử dụng lệnh sau

Công việc đã lên lịch

Công việc đã lên lịch trong Kubernetes sử dụng Cronetes , công việc này sẽ nhận công việc của Kubernetes và khởi chạy chúng trong cụm Kubernetes.

• Lập lịch công việc sẽ chạy một nhóm tại một thời điểm xác định.
• Một công việc nhại được tạo cho nó tự động gọi nó.

Lưu ý – Tính năng của công việc đã lên lịch được phiên bản 1.4 hỗ trợ và API betch / v2alpha 1 được bật bằng cách chuyển –runtime-config = batch / v2alpha1 trong khi hiển thị máy chủ API. Chúng tôi sẽ sử dụng cùng một yaml mà chúng tôi đã sử dụng để tạo công việc và biến nó thành công việc theo lịch trình.

apiVersion: v1
kind: Job
metadata:
   name: py
spec:
   schedule: h/30 * * * * ? -------------------> 1
   template:
      metadata
         name: py
      spec:
         containers:
         - name: py
         image: python
         args:
/bin/sh -------> 2
-c
ps –eaf ------------> 3
restartPocliy: OnFailure

Trong đoạn mã trên, chúng tôi đã xác định –

• lịch trình: h / 30 * * * *? → Lên lịch để công việc chạy sau mỗi 30 phút.
• / bin / sh: Điều này sẽ nhập vào vùng chứa với / bin / sh
• ps –eaf → Sẽ chạy lệnh ps -eaf trên máy và liệt kê tất cả quá trình đang chạy bên trong một vùng chứa.

Khái niệm công việc đã lên lịch này rất hữu ích khi chúng ta đang cố gắng xây dựng và chạy một tập hợp các nhiệm vụ tại một thời điểm xác định và sau đó hoàn thành quy trình.

Kubernetes – Nhãn & Bộ chọn (xem thêm)

The post Kubernetes – Hình ảnh appeared first on Dongthoigian.net.

Sau khi thiết lập IaaS trên bất kỳ đám mây nào hoàn tất, bạn cần định cấu hình Master và Node .

Lưu ý – Thiết lập được hiển thị cho các máy Ubuntu. Điều này cũng có thể được thiết lập trên các máy Linux khác.

Điều kiện tiên quyết

Cài đặt Docker – Docker là bắt buộc trên tất cả các phiên bản của Kubernetes. Sau đây là các bước để cài đặt Docker.

Bước 1 – Đăng nhập vào máy bằng tài khoản người dùng root.

Bước 2 – Cập nhật thông tin gói. Đảm bảo rằng gói apt đang hoạt động.

Bước 3 – Chạy các lệnh sau.

$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates

Bước 4 – Thêm khóa GPG mới.

$ sudo apt-key adv \
   --keyserver hkp://ha.pool.sks-keyservers.net:80 \
   --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ echo "deb https://apt.dockerproject.org/repo ubuntu-trusty main" | sudo tee
/etc/apt/sources.list.d/docker.list

Bước 5 – Cập nhật hình ảnh gói API.

$ sudo apt-get update

Khi tất cả các tác vụ trên đã hoàn tất, bạn có thể bắt đầu với quá trình cài đặt thực tế của công cụ Docker. Tuy nhiên, trước khi điều này, bạn cần xác minh rằng phiên bản hạt nhân bạn đang sử dụng là chính xác.

Cài đặt Docker Engine

Chạy các lệnh sau để cài đặt công cụ Docker.

Bước 1 – Đăng nhập vào máy.

Bước 2 – Cập nhật chỉ mục gói.

$ sudo apt-get update

Bước 3 – Cài đặt Docker Engine bằng lệnh sau.

$ sudo apt-get install docker-engine

Bước 4 – Khởi động trình nền Docker

$ sudo apt-get install docker-engine

Bước 5 – Để xem Docker đã được cài đặt chưa, hãy sử dụng lệnh sau.

$ sudo docker run hello-world

Cài đặt etcd 2.0

Điều này cần được cài đặt trên Kubernetes Master Machine. Để cài đặt nó, hãy chạy các lệnh sau.

$ curl -L https://github.com/coreos/etcd/releases/download/v2.0.0/etcd
-v2.0.0-linux-amd64.tar.gz -o etcd-v2.0.0-linux-amd64.tar.gz ->1
$ tar xzvf etcd-v2.0.0-linux-amd64.tar.gz ------>2
$ cd etcd-v2.0.0-linux-amd64 ------------>3
$ mkdir /opt/bin ------------->4
$ cp etcd* /opt/bin ----------->5

Trong tập lệnh trên –

• Đầu tiên, chúng tôi tải xuống etcd . Lưu cái này với tên được chỉ định.
• Sau đó, chúng ta phải mở gói tar.
• Chúng tôi thực hiện một dir. bên trong thùng có tên / opt.
• Sao chép tệp đã giải nén vào vị trí đích.

Bây giờ chúng tôi đã sẵn sàng xây dựng Kubernetes. Chúng ta cần cài đặt Kubernetes trên tất cả các máy trong cụm.

$ git clone https://github.com/GoogleCloudPlatform/kubernetes.git
$ cd kubernetes
$ make release

Lệnh trên sẽ tạo một _output dir trong thư mục gốc của thư mục kubernetes. Tiếp theo, chúng ta có thể giải nén thư mục vào bất kỳ thư mục nào mà chúng ta chọn / opt / bin, v.v.

Tiếp theo, đến phần kết nối mạng, trong đó chúng ta cần thực sự bắt đầu với việc thiết lập nút chính và nút Kubernetes. Để làm điều này, chúng tôi sẽ tạo một mục nhập trong tệp máy chủ lưu trữ có thể được thực hiện trên máy nút.

$ echo "<IP address of master machine> kube-master
< IP address of Node Machine>" >> /etc/hosts

Sau đây sẽ là kết quả của lệnh trên.

Bây giờ, chúng ta sẽ bắt đầu với cấu hình thực tế trên Kubernetes Master.

Đầu tiên, chúng tôi sẽ bắt đầu sao chép tất cả các tệp cấu hình vào đúng vị trí của chúng.

$ cp <Current dir. location>/kube-apiserver /opt/bin/
$ cp <Current dir. location>/kube-controller-manager /opt/bin/
$ cp <Current dir. location>/kube-kube-scheduler /opt/bin/
$ cp <Current dir. location>/kubecfg /opt/bin/
$ cp <Current dir. location>/kubectl /opt/bin/
$ cp <Current dir. location>/kubernetes /opt/bin/

Lệnh trên sẽ sao chép tất cả các tệp cấu hình vào vị trí cần thiết. Bây giờ chúng ta sẽ quay lại cùng một thư mục mà chúng ta đã xây dựng thư mục Kubernetes.

$ cp kubernetes/cluster/ubuntu/init_conf/kube-apiserver.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-controller-manager.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-kube-scheduler.conf /etc/init/

$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-apiserver /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-controller-manager /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-kube-scheduler /etc/init.d/

$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/

Bước tiếp theo là cập nhật tệp cấu hình đã sao chép trong / etc. dir. Định cấu hình etcd trên master bằng lệnh sau.

$ ETCD_OPTS = "-listen-client-urls = http://kube-master:4001"

Định cấu hình kube-apiserver

Đối với điều này trên bản chính, chúng ta cần chỉnh sửa tệp / etc / default / kube-apiserver mà chúng ta đã sao chép trước đó.

$ KUBE_APISERVER_OPTS = "--address = 0.0.0.0 \
--port = 8080 \
--etcd_servers = <The path that is configured in ETCD_OPTS> \
--portal_net = 11.1.1.0/24 \
--allow_privileged = false \
--kubelet_port = < Port you want to configure> \
--v = 0"

Định cấu hình Trình quản lý bộ điều khiển kube

Chúng ta cần thêm nội dung sau vào / etc / default / kube-controller-manager .

$ KUBE_CONTROLLER_MANAGER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--machines = kube-minion \ -----> #this is the kubernatics node
--v = 0

Tiếp theo, định cấu hình bộ lập lịch kube trong tệp tương ứng.

$ KUBE_SCHEDULER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--v = 0"

Khi tất cả các nhiệm vụ trên đã hoàn thành, chúng ta nên tiếp tục bằng cách đưa Kubernetes Master lên. Để làm điều này, chúng tôi sẽ khởi động lại Docker.

$ service docker restart

Cấu hình nút Kubernetes

Nút Kubernetes sẽ chạy hai dịch vụ kubelet và kube-proxy . Trước khi tiếp tục, chúng ta cần sao chép các tệp nhị phân mà chúng ta đã tải xuống vào các thư mục yêu cầu của chúng, nơi chúng ta muốn định cấu hình nút kubernetes.

Sử dụng cùng một phương pháp sao chép các tệp mà chúng tôi đã làm cho kubernetes master. Vì nó sẽ chỉ chạy kubelet và kube-proxy, chúng tôi sẽ định cấu hình chúng.

$ cp <Path of the extracted file>/kubelet /opt/bin/
$ cp <Path of the extracted file>/kube-proxy /opt/bin/
$ cp <Path of the extracted file>/kubecfg /opt/bin/
$ cp <Path of the extracted file>/kubectl /opt/bin/
$ cp <Path of the extracted file>/kubernetes /opt/bin/

Bây giờ, chúng tôi sẽ sao chép nội dung vào dir thích hợp.

$ cp kubernetes/cluster/ubuntu/init_conf/kubelet.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-proxy.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kubelet /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-proxy /etc/init.d/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/

Chúng tôi sẽ định cấu hình các tệp conf kubelet và kube-proxy . Chúng tôi sẽ định cấu hình /etc/init/kubelet.conf .

$ KUBELET_OPTS = "--address = 0.0.0.0 \
--port = 10250 \
--hostname_override = kube-minion \
--etcd_servers = http://kube-master:4001 \
--enable_server = true
--v = 0"
/

Đối với kube-proxy, chúng tôi sẽ cấu hình bằng lệnh sau.

$ KUBE_PROXY_OPTS = "--etcd_servers = http://kube-master:4001 \
--v = 0"
/etc/init/kube-proxy.conf

Cuối cùng, chúng tôi sẽ khởi động lại dịch vụ Docker.

$ service docker restart

Bây giờ chúng ta đã hoàn thành cấu hình. Bạn có thể kiểm tra bằng cách chạy các lệnh sau.

$ /opt/bin/kubectl get minions

Kubernetes – Hình ảnh (xem thêm)

The post Kubernetes – Thiết lập appeared first on Dongthoigian.net.