Kubernetes è una piattaforma open source sviluppata da Google per la gestione di applicazioni containerizzate in un cluster di server. Si basa su un decennio e mezzo di esperienza che Google ha con la gestione di cluster di container su larga scala e fornisce agli sviluppatori un'infrastruttura in stile Google, sfruttando i migliori progetti open source, come:
- Docker : una tecnologia di contenitore di applicazioni.
- Etcd : un archivio dati con valori-chiave distribuito che gestisce le informazioni a livello di cluster e fornisce il rilevamento del servizio.
- Flanella : un tessuto di rete overlay che consente la connettività del contenitore su più server.
Kubernetes consente agli sviluppatori di definire la propria infrastruttura applicativa in modo dichiarativo tramite file YAML e astrazioni come Pod, RC e servizi (ne parleremo più avanti) e garantisce che il cluster sottostante corrisponda sempre allo stato definito dall'utente.
Alcune delle sue caratteristiche includono:
- Pianificazione automatica delle risorse di sistema e posizionamento automatico dei contenitori di applicazioni in un cluster.
- Scalare le applicazioni al volo con un solo comando.
- Aggiornamenti continui con zero tempi di inattività.
- Autoguarigione: riprogrammazione automatica di un'applicazione in caso di errore di un server, riavvio automatico dei contenitori, controlli di integrità.
Passa all'installazione se conosci già Kubernetes.
Concetti basilari
Kubernetes offre le seguenti astrazioni (unità logiche) agli sviluppatori:
- Cialde.
- Controller di replica.
- Etichette.
- Servizi.
Pods
È l'unità base dei carichi di lavoro di Kubernetes. Un pod modella un "host logico" specifico dell'applicazione in un ambiente containerizzato. In parole povere, modella un gruppo di applicazioni o servizi che erano in esecuzione sullo stesso server nel mondo pre-container. I contenitori all'interno di un pod condividono lo stesso spazio dei nomi di rete e possono anche condividere volumi di dati.
Controller di replica
I pod sono ideali per raggruppare più contenitori in unità di applicazioni logiche, ma non offrono replica o riprogrammazione in caso di errore del server.
Qui è dove un controller di replica o RC è utile. Un RC garantisce che un numero di pod di un determinato servizio sia sempre in esecuzione nel cluster.
etichette
Sono metadati chiave-valore che possono essere collegati a qualsiasi risorsa Kubernetes (pod, RC, servizi, nodi, ...).
Servizi
I pod e i controller di replica sono ottimi per la distribuzione e la distribuzione di applicazioni in un cluster, ma i pod hanno IP effimeri che cambiano dopo la riprogrammazione o il riavvio del contenitore.
Un servizio Kubernetes fornisce un endpoint stabile (IP virtuale fisso + associazione porta ai server host) per un gruppo di pod gestiti da un controller di replica.
Cluster Kubernetes
Nella sua forma più semplice, un cluster Kubernetes è composto da due tipi di nodi:
- 1 maestro Kubernetes.
- N nodi Kubernetes.
Maestro di Kubernetes
Il master Kubernetes è l'unità di controllo dell'intero cluster.
I componenti principali del master sono:
- Etcd: un archivio dati disponibile a livello globale che memorizza informazioni sul cluster e sui servizi e applicazioni in esecuzione sul cluster.
- Server API Kube: questo è il principale hub di gestione del cluster Kubernetes ed espone un'interfaccia RESTful.
- Controller manager: gestisce la replica delle applicazioni gestite dai controller di replica.
- Scheduler: tiene traccia dell'utilizzo delle risorse in tutto il cluster e assegna i carichi di lavoro di conseguenza.
Nodo Kubernetes
Il nodo Kubernetes sono server di lavoro responsabili dell'esecuzione dei pod.
I componenti principali di un nodo sono:
- Docker: un demone che esegue contenitori di applicazioni definiti in pod.
- Kubelet: un'unità di controllo per pod in un sistema locale.
- Kube-proxy: un proxy di rete che garantisce il routing corretto per i servizi Kubernetes.
Installazione
In questa guida, creeremo un cluster a 3 nodi utilizzando i server CentOS 7:
- 1 Kubernetes master (kube-master)
- 2 nodi Kubernetes (kube-node1, kube-node2)
Puoi aggiungere tutti i nodi extra che desideri in seguito seguendo la stessa procedura di installazione per i nodi Kubernetes.
Tutti i nodi
Configura i nomi host e /etc/hosts
:
# /etc/hostname
kube-master
# or kube-node1, kube-node2
# append to /etc/hosts
replace-with-master-server-ip kube-master
replace-with-node1-ip kube-node1
replace-with-node2-ip kube-node2
Disabilita firewalld:
systemctl disable firewalld
systemctl stop firewalld
Maestro di Kubernetes
Installa i pacchetti master Kubernetes:
yum install etcd kubernetes-master
Configurazione:
# /etc/etcd/etcd.conf
# leave rest of the lines unchanged
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"
ETCD_LISTEN_PEER_URLS="http://localhost:2380"
ETCD_ADVERTISE_CLIENT_URLS="http://0.0.0.0:2379"
# /etc/kubernetes/config
# leave rest of the lines unchanged
KUBE_MASTER="--master=http://kube-master:8080"
# /etc/kubernetes/apiserver
# leave rest of the lines unchanged
KUBE_API_ADDRESS="--address=0.0.0.0"
KUBE_ETCD_SERVERS="--etcd_servers=http://kube-master:2379"
Avvia Etcd:
systemctl start etcd
Installa e configura il tessuto di rete overlay Flannel (questo è necessario affinché i contenitori in esecuzione su server diversi possano vedersi):
yum install flannel
Crea un file di configurazione Flanella ( flannel-config.json
):
{
"Network": "10.20.0.0/16",
"SubnetLen": 24,
"Backend": {
"Type": "vxlan",
"VNI": 1
}
}
Imposta la configurazione della flanella nel server Etcd:
etcdctl set coreos.com/network/config < flannel-config.json
Punta Flannel al server Etcd:
# /etc/sysconfig/flanneld
FLANNEL_ETCD="http://kube-master:2379"
Abilitare i servizi in modo che si avviino all'avvio:
systemctl enable etcd
systemctl enable kube-apiserver
systemctl enable kube-controller-manager
systemctl enable kube-scheduler
systemctl enable flanneld
Riavvia il server.
Nodo Kubernetes
Installa i pacchetti di nodi Kubernetes:
yum install docker kubernetes-node
I prossimi due passaggi configureranno Docker per l'utilizzo di overlayfs per prestazioni migliori. Per maggiori informazioni visita questo post del blog :
Elimina la directory di archiviazione della finestra mobile corrente:
systemctl stop docker
rm -rf /var/lib/docker
Cambia file di configurazione:
# /etc/sysconfig/docker
# leave rest of lines unchanged
OPTIONS='--selinux-enabled=false'
# /etc/sysconfig/docker
# leave rest of lines unchanged
DOCKER_STORAGE_OPTIONS=-s overlay
Configura kube-node1 per usare il nostro master precedentemente configurato:
# /etc/kubernetes/config
# leave rest of lines unchanged
KUBE_MASTER="--master=http://kube-master:8080"
# /etc/kubernetes/kubelet
# leave rest of the lines unchanged
KUBELET_ADDRESS="--address=0.0.0.0"
# comment this line, so that the actual hostname is used to register the node
# KUBELET_HOSTNAME="--hostname_override=127.0.0.1"
KUBELET_API_SERVER="--api_servers=http://kube-master:8080"
Installa e configura il tessuto di rete di overlay Flannel (di nuovo - questo è necessario affinché i contenitori in esecuzione su server diversi possano vedersi):
yum install flannel
Punta Flannel al server Etcd:
# /etc/sysconfig/flanneld
FLANNEL_ETCD="http://kube-master:2379"
Abilita servizi:
systemctl enable docker
systemctl enable flanneld
systemctl enable kubelet
systemctl enable kube-proxy
Riavvia il server.
Metti alla prova il tuo server Kubernetes
Dopo il riavvio di tutti i server, verificare se il cluster Kubernetes è operativo:
[root@kube-master ~]# kubectl get nodes
NAME LABELS STATUS
kube-node1 kubernetes.io/hostname=kube-node1 Ready
kube-node2 kubernetes.io/hostname=kube-node2 Ready
Esempio: distribuzione di una griglia di selenio mediante Kubernetes
Il selenio è un framework per l'automazione dei browser a scopo di test. È un potente strumento dell'arsenale di qualsiasi sviluppatore web.
La griglia del selenio consente l'esecuzione remota scalabile e parallela di test attraverso un cluster di nodi del selenio collegati a un hub centrale del selenio.
Poiché i nodi Selenium sono essi stessi apolidi e la quantità di nodi che eseguiamo è flessibile, a seconda dei nostri carichi di lavoro di test, questa è un'applicazione candidata perfetta da distribuire su un cluster Kubernetes.
Nella sezione successiva, implementeremo una griglia composta da 5 contenitori di applicazioni:
- 1 hub centrale al selenio che sarà l'endpoint remoto a cui si collegheranno i nostri test.
- 2 nodi Selenium con Firefox.
- 2 nodi Selenium con Chrome.
Strategia di implementazione
Per gestire automaticamente la replica e l'autoguarigione, creeremo un controller di replica Kubernetes per ogni tipo di contenitore dell'applicazione elencato sopra.
Per fornire agli sviluppatori che eseguono test un endpoint hub Selenium stabile, creeremo un servizio Kubernetes collegato al controller di replica hub.
Hub al selenio
Controller di replica
# selenium-hub-rc.yaml
apiVersion: v1
kind: ReplicationController
metadata:
name: selenium-hub
spec:
replicas: 1
selector:
name: selenium-hub
template:
metadata:
labels:
name: selenium-hub
spec:
containers:
- name: selenium-hub
image: selenium/hub
ports:
- containerPort: 4444
Distribuzione:
[root@kube-master ~]# kubectl create -f selenium-hub-rc.yaml
replicationcontrollers/selenium-hub
[root@kube-master ~]# kubectl get rc
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
selenium-hub selenium-hub selenium/hub name=selenium-hub 1
[root@kube-master ~]# kubectl get pods
NAME READY STATUS RESTARTS AGE
selenium-hub-pilc8 1/1 Running 0 50s
[root@kube-master ~]# kubectl describe pod selenium-hub-pilc8
Name: selenium-hub-pilc8
Namespace: default
Image(s): selenium/hub
Node: kube-node2/45.63.16.92
Labels: name=selenium-hub
Status: Running
Reason:
Message:
IP: 10.20.101.2
Replication Controllers: selenium-hub (1/1 replicas created)
Containers:
selenium-hub:
Image: selenium/hub
State: Running
Started: Sat, 24 Oct 2015 16:01:39 +0000
Ready: True
Restart Count: 0
Conditions:
Type Status
Ready True
Events:
FirstSeen LastSeen Count From SubobjectPath Reason Message
Sat, 24 Oct 2015 16:01:02 +0000 Sat, 24 Oct 2015 16:01:02 +0000 1 {scheduler } scheduled Successfully assigned selenium-hub-pilc8 to kube-node2
Sat, 24 Oct 2015 16:01:05 +0000 Sat, 24 Oct 2015 16:01:05 +0000 1 {kubelet kube-node2} implicitly required container POD pulled Successfully pulled Pod container image "gcr.io/google_containers/pause:0.8.0"
Sat, 24 Oct 2015 16:01:05 +0000 Sat, 24 Oct 2015 16:01:05 +0000 1 {kubelet kube-node2} implicitly required container POD created Created with docker id 6de00106b19c
Sat, 24 Oct 2015 16:01:05 +0000 Sat, 24 Oct 2015 16:01:05 +0000 1 {kubelet kube-node2} implicitly required container POD started Started with docker id 6de00106b19c
Sat, 24 Oct 2015 16:01:39 +0000 Sat, 24 Oct 2015 16:01:39 +0000 1 {kubelet kube-node2} spec.containers pulled Successfully pulled image "selenium/hub"
Sat, 24 Oct 2015 16:01:39 +0000 Sat, 24 Oct 2015 16:01:39 +0000 1 {kubelet kube-node2} spec.containers created Created with docker id 7583cc09268c
Sat, 24 Oct 2015 16:01:39 +0000 Sat, 24 Oct 2015 16:01:39 +0000 1 {kubelet kube-node2} spec.containers started Started with docker id 7583cc09268c
Qui possiamo vedere che Kubernetes ha posizionato il mio contenitore hub selenio su kube-node2.
Servizio
# selenium-hub-service.yaml
apiVersion: v1
kind: Service
metadata:
name: selenium-hub
spec:
type: NodePort
ports:
- port: 4444
protocol: TCP
nodePort: 30000
selector:
name: selenium-hub
Distribuzione:
[root@kube-master ~]# kubectl create -f selenium-hub-service.yaml
You have exposed your service on an external port on all nodes in your
cluster. If you want to expose this service to the external internet, you may
need to set up firewall rules for the service port(s) (tcp:30000) to serve traffic.
See http://releases.k8s.io/HEAD/docs/user-guide/services-firewalls.md for more details.
services/selenium-hub
[root@kube-master ~]# kubectl get services
NAME LABELS SELECTOR IP(S) PORT(S)
kubernetes component=apiserver,provider=kubernetes <none> 10.254.0.1 443/TCP
selenium-hub <none> name=selenium-hub 10.254.124.73 4444/TCP
Dopo aver distribuito il servizio, sarà raggiungibile da:
- Qualsiasi nodo Kubernetes, tramite l'IP virtuale 10.254.124.73 e la porta 4444.
- Reti esterne, tramite qualsiasi IP pubblico di qualsiasi nodo Kubernetes, sulla porta 30000.

(utilizzando l'IP pubblico di un altro nodo Kubernetes)
Nodi di selenio
Controller di replica dei nodi Firefox:
# selenium-node-firefox-rc.yaml
apiVersion: v1
kind: ReplicationController
metadata:
name: selenium-node-firefox
spec:
replicas: 2
selector:
name: selenium-node-firefox
template:
metadata:
labels:
name: selenium-node-firefox
spec:
containers:
- name: selenium-node-firefox
image: selenium/node-firefox
ports:
- containerPort: 5900
env:
- name: HUB_PORT_4444_TCP_ADDR
value: "replace_with_service_ip"
- name: HUB_PORT_4444_TCP_PORT
value: "4444"
Distribuzione:
Sostituire replace_with_service_ip
in selenium-node-firefox-rc.yaml
con l'attuale servizio di IP hub selenio, in questo caso 10.254.124.73.
[root@kube-master ~]# kubectl create -f selenium-node-firefox-rc.yaml
replicationcontrollers/selenium-node-firefox
[root@kube-master ~]# kubectl get rc
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
selenium-hub selenium-hub selenium/hub name=selenium-hub 1
selenium-node-firefox selenium-node-firefox selenium/node-firefox name=selenium-node-firefox 2
[root@kube-master ~]# kubectl get pods
NAME READY STATUS RESTARTS AGE
selenium-hub-pilc8 1/1 Running 1 1h
selenium-node-firefox-lc6qt 1/1 Running 0 2m
selenium-node-firefox-y9qjp 1/1 Running 0 2m
[root@kube-master ~]# kubectl describe pod selenium-node-firefox-lc6qt
Name: selenium-node-firefox-lc6qt
Namespace: default
Image(s): selenium/node-firefox
Node: kube-node2/45.63.16.92
Labels: name=selenium-node-firefox
Status: Running
Reason:
Message:
IP: 10.20.101.3
Replication Controllers: selenium-node-firefox (2/2 replicas created)
Containers:
selenium-node-firefox:
Image: selenium/node-firefox
State: Running
Started: Sat, 24 Oct 2015 17:08:37 +0000
Ready: True
Restart Count: 0
Conditions:
Type Status
Ready True
Events:
FirstSeen LastSeen Count From SubobjectPath Reason Message
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {scheduler } scheduled Successfully assigned selenium-node-firefox-lc6qt to kube-node2
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node2} implicitly required container POD pulled Pod container image "gcr.io/google_containers/pause:0.8.0" already present on machine
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node2} implicitly required container POD created Created with docker id cdcb027c6548
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node2} implicitly required container POD started Started with docker id cdcb027c6548
Sat, 24 Oct 2015 17:08:36 +0000 Sat, 24 Oct 2015 17:08:36 +0000 1 {kubelet kube-node2} spec.containers pulled Successfully pulled image "selenium/node-firefox"
Sat, 24 Oct 2015 17:08:36 +0000 Sat, 24 Oct 2015 17:08:36 +0000 1 {kubelet kube-node2} spec.containers created Created with docker id 8931b7f7a818
Sat, 24 Oct 2015 17:08:37 +0000 Sat, 24 Oct 2015 17:08:37 +0000 1 {kubelet kube-node2} spec.containers started Started with docker id 8931b7f7a818
[root@kube-master ~]# kubectl describe pod selenium-node-firefox-y9qjp
Name: selenium-node-firefox-y9qjp
Namespace: default
Image(s): selenium/node-firefox
Node: kube-node1/185.92.221.67
Labels: name=selenium-node-firefox
Status: Running
Reason:
Message:
IP: 10.20.92.3
Replication Controllers: selenium-node-firefox (2/2 replicas created)
Containers:
selenium-node-firefox:
Image: selenium/node-firefox
State: Running
Started: Sat, 24 Oct 2015 17:08:13 +0000
Ready: True
Restart Count: 0
Conditions:
Type Status
Ready True
Events:
FirstSeen LastSeen Count From SubobjectPath Reason Message
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {scheduler } scheduled Successfully assigned selenium-node-firefox-y9qjp to kube-node1
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node1} implicitly required container POD pulled Pod container image "gcr.io/google_containers/pause:0.8.0" already present on machine
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node1} implicitly required container POD created Created with docker id ea272dd36bd5
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node1} implicitly required container POD started Started with docker id ea272dd36bd5
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node1} spec.containers created Created with docker id 6edbd6b9861d
Sat, 24 Oct 2015 17:08:13 +0000 Sat, 24 Oct 2015 17:08:13 +0000 1 {kubelet kube-node1} spec.containers started Started with docker id 6edbd6b9861d
Come possiamo vedere, Kubernetes ha creato 2 repliche di selenium-firefox-node
e le ha distribuite in tutto il cluster. Pod si selenium-node-firefox-lc6qt
trova su kube-node2, mentre pod si selenium-node-firefox-y9qjp
trova su kube-node1.
Ripetiamo lo stesso processo per i nostri nodi Selenium Chrome.
Controller di replica del nodo Chrome:
# selenium-node-chrome-rc.yaml
apiVersion: v1
kind: ReplicationController
metadata:
name: selenium-node-chrome
labels:
app: selenium-node-chrome
spec:
replicas: 2
selector:
app: selenium-node-chrome
template:
metadata:
labels:
app: selenium-node-chrome
spec:
containers:
- name: selenium-node-chrome
image: selenium/node-chrome
ports:
- containerPort: 5900
env:
- name: HUB_PORT_4444_TCP_ADDR
value: "replace_with_service_ip"
- name: HUB_PORT_4444_TCP_PORT
value: "4444"
Distribuzione:
[root@kube-master ~]# kubectl create -f selenium-node-chrome-rc.yaml
replicationcontrollers/selenium-node-chrome
[root@kube-master ~]# kubectl get rc
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
selenium-hub selenium-hub selenium/hub name=selenium-hub 1
selenium-node-chrome selenium-node-chrome selenium/node-chrome app=selenium-node-chrome 2
selenium-node-firefox selenium-node-firefox selenium/node-firefox name=selenium-node-firefox 2
[root@kube-master ~]# kubectl get pods
NAME READY STATUS RESTARTS AGE
selenium-hub-pilc8 1/1 Running 1 1h
selenium-node-chrome-9u1ld 1/1 Running 0 1m
selenium-node-chrome-mgi52 1/1 Running 0 1m
selenium-node-firefox-lc6qt 1/1 Running 0 11m
selenium-node-firefox-y9qjp 1/1 Running 0 11m
Avvolgendo
In questa guida, abbiamo creato un piccolo cluster Kubernetes di 3 server (1 controller principale + 2 lavoratori).
Utilizzando pod, RC e un servizio, abbiamo implementato con successo una griglia Selenium composta da un hub centrale e 4 nodi, che consente agli sviluppatori di eseguire 4 test Selenium simultanei contemporaneamente sul cluster.
Kubernetes pianificava automaticamente i contenitori nell'intero cluster.

Self-healing
Kubernetes ripianifica automaticamente i pod su server sani se uno o più dei nostri server si arrestano. Nel mio esempio, kube-node2 sta attualmente eseguendo il pod hub Selenium e 1 pod nodo Selenium Firefox.
[root@kube-node2 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5617399f146c selenium/node-firefox "/opt/bin/entry_poin 5 minutes ago Up 5 minutes k8s_selenium-node-firefox.46e635d8_selenium-node-firefox-zmj1r_default_31c89517-7a75-11e5-8648-5600001611e0_baae8e00
185230a3b431 gcr.io/google_containers/pause:0.8.0 "/pause" 5 minutes ago Up 5 minutes k8s_POD.3805e8b7_selenium-node-firefox-zmj1r_default_31c89517-7a75-11e5-8648-5600001611e0_40f809df
fdd5834c249d selenium/hub "/opt/bin/entry_poin About an hour ago Up About an hour k8s_selenium-hub.cb8bf0ed_selenium-hub-pilc8_default_6c98c1ff-7a68-11e5-8648-5600001611e0_5765e2c9
00e4ccb0bda8 gcr.io/google_containers/pause:0.8.0 "/pause" About an hour ago Up About an hour k8s_POD.3b3ee8b9_selenium-hub-pilc8_default_6c98c1ff-7a68-11e5-8648-5600001611e0_8398ac33
Simuleremo il fallimento del server spegnendo kube-node2. Dopo un paio di minuti, dovresti vedere che i contenitori in esecuzione su kube-node2 sono stati riprogrammati su kube-node1, garantendo un'interruzione minima del servizio.
[root@kube-node1 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5bad5f582698 selenium/hub "/opt/bin/entry_poin 19 minutes ago Up 19 minutes k8s_selenium-hub.cb8bf0ed_selenium-hub-hycf2_default_fe9057cf-7a76-11e5-8648-5600001611e0_ccaad50a
dd1565a94919 selenium/node-firefox "/opt/bin/entry_poin 20 minutes ago Up 20 minutes k8s_selenium-node-firefox.46e635d8_selenium-node-firefox-g28z5_default_fe932673-7a76-11e5-8648-5600001611e0_fc79f977
2be1a316aa47 gcr.io/google_containers/pause:0.8.0 "/pause" 20 minutes ago Up 20 minutes k8s_POD.3805e8b7_selenium-node-firefox-g28z5_default_fe932673-7a76-11e5-8648-5600001611e0_dc204ad2
da75a0242a9e gcr.io/google_containers/pause:0.8.0 "/pause" 20 minutes ago Up 20 minutes k8s_POD.3b3ee8b9_selenium-hub-hycf2_default_fe9057cf-7a76-11e5-8648-5600001611e0_1b10c0e7
c611b68330de selenium/node-firefox "/opt/bin/entry_poin 33 minutes ago Up 33 minutes k8s_selenium-node-firefox.46e635d8_selenium-node-firefox-8ylo2_default_31c8a8f3-7a75-11e5-8648-5600001611e0_922af821
828031da6b3c gcr.io/google_containers/pause:0.8.0 "/pause" 33 minutes ago Up 33 minutes k8s_POD.3805e8b7_selenium-node-firefox-8ylo2_default_31c8a8f3-7a75-11e5-8648-5600001611e0_289cd555
caf4e725512e selenium/node-chrome "/opt/bin/entry_poin 46 minutes ago Up 46 minutes k8s_selenium-node-chrome.362a34ee_selenium-node-chrome-mgi52_default_392a2647-7a73-11e5-8648-5600001611e0_3c6e855a
409a20770787 selenium/node-chrome "/opt/bin/entry_poin 46 minutes ago Up 46 minutes k8s_selenium-node-chrome.362a34ee_selenium-node-chrome-9u1ld_default_392a15a4-7a73-11e5-8648-5600001611e0_ac3f0191
7e2d942422a5 gcr.io/google_containers/pause:0.8.0 "/pause" 47 minutes ago Up 47 minutes k8s_POD.3805e8b7_selenium-node-chrome-9u1ld_default_392a15a4-7a73-11e5-8648-5600001611e0_f5858b73
a3a65ea99a99 gcr.io/google_containers/pause:0.8.0 "/pause" 47 minutes ago Up 47 minutes k8s_POD.3805e8b7_selenium-node-chrome-mgi52_default_392a2647-7a73-11e5-8648-5600001611e0_20a70ab6
Ridimensionamento della griglia del selenio
Ridimensionare la griglia del selenio è semplicissimo con Kubernetes. Immagina che invece di 2 nodi Firefox, vorrei eseguire 4. L'upscaling può essere eseguito con un singolo comando:
[root@kube-master ~]# kubectl scale rc selenium-node-firefox --replicas=4
scaled
[root@kube-master ~]# kubectl get rc
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
selenium-hub selenium-hub selenium/hub name=selenium-hub 1
selenium-node-chrome selenium-node-chrome selenium/node-chrome app=selenium-node-chrome 2
selenium-node-firefox selenium-node-firefox selenium/node-firefox name=selenium-node-firefox 4
[root@kube-master ~]# kubectl get pods
NAME READY STATUS RESTARTS AGE
selenium-hub-pilc8 1/1 Running 1 1h
selenium-node-chrome-9u1ld 1/1 Running 0 14m
selenium-node-chrome-mgi52 1/1 Running 0 14m
selenium-node-firefox-8ylo2 1/1 Running 0 40s
selenium-node-firefox-lc6qt 1/1 Running 0 24m
selenium-node-firefox-y9qjp 1/1 Running 0 24m
selenium-node-firefox-zmj1r 1/1 Running 0 40s
