Comenzando con Kubernetes en CentOS 7

• Conceptos básicos
• Racimo de Kubernetes
• Instalación
• Pon a prueba tu servidor Kubernetes
• Ejemplo: Implementar una cuadrícula de selenio usando Kubernetes
• Autocuración
• Escalando su rejilla de selenio

Kubernetes es una plataforma de código abierto desarrollada por Google para administrar aplicaciones en contenedores en un grupo de servidores. Se basa en una década y media de experiencia que Google tiene con la ejecución de clústeres de contenedores a escala , y proporciona a los desarrolladores una infraestructura de estilo Google, aprovechando los mejores proyectos de código abierto, como:

• Docker : una tecnología de contenedor de aplicaciones.
• Etcd : un almacén de datos de valor clave distribuido que administra la información de todo el clúster y proporciona descubrimiento de servicios.
• Franela : una estructura de red superpuesta que permite la conectividad de contenedores en varios servidores.

Kubernetes permite a los desarrolladores definir su infraestructura de aplicaciones de manera declarativa a través de archivos YAML y abstracciones como Pods, RC y Servicios (más sobre esto más adelante) y asegura que el clúster subyacente coincida con el estado definido por el usuario en todo momento.

Algunas de sus características incluyen:

• Programación automática de recursos del sistema y colocación automática de contenedores de aplicaciones en un clúster.
• Escalar aplicaciones sobre la marcha con un solo comando.
• Actualizaciones continuas con tiempo de inactividad cero.
• Autocuración: reprogramación automática de una aplicación si falla un servidor, reinicio automático de contenedores, comprobaciones de estado.

Vaya a Instalación si ya está familiarizado con Kubernetes.

Conceptos básicos

Kubernetes ofrece las siguientes abstracciones (unidades lógicas) a los desarrolladores:

• Vainas
• Controladores de replicación.
• Etiquetas.
• Servicios.

Vainas

Es la unidad básica de las cargas de trabajo de Kubernetes. Un pod modela un "host lógico" específico de la aplicación en un entorno contenedorizado. En términos simples, modela un grupo de aplicaciones o servicios que solían ejecutarse en el mismo servidor en el mundo previo al contenedor. Los contenedores dentro de un pod comparten el mismo espacio de nombres de red y también pueden compartir volúmenes de datos.

Controladores de replicación

Los pods son excelentes para agrupar múltiples contenedores en unidades lógicas de aplicación, pero no ofrecen replicación o reprogramación en caso de falla del servidor.

Aquí es donde un controlador de replicación o RC es útil. Un RC garantiza que una serie de pods de un servicio determinado siempre se ejecutan en el clúster.

Etiquetas

Son metadatos de valor clave que se pueden adjuntar a cualquier recurso de Kubernetes (pods, RC, servicios, nodos, ...).

Servicios

Los pods y los controladores de replicación son excelentes para implementar y distribuir aplicaciones en un clúster, pero los pods tienen IP efímeras que cambian al reprogramar o reiniciar el contenedor.

Un servicio de Kubernetes proporciona un punto final estable (enlace de puerto IP + virtual fijo a los servidores host) para un grupo de pods administrados por un controlador de replicación.

Racimo de Kubernetes

En su forma más simple, un clúster de Kubernetes está compuesto por dos tipos de nodos:

• 1 maestro de Kubernetes.
• N nodos de Kubernetes.

Maestro Kubernetes

El maestro de Kubernetes es la unidad de control de todo el clúster.

Los componentes principales del maestro son:

• Etcd: un almacén de datos disponible a nivel mundial que almacena información sobre el clúster y los servicios y aplicaciones que se ejecutan en el clúster.
• Servidor API de Kube: este es el principal centro de administración del clúster de Kubernetes y expone una interfaz RESTful.
• Administrador de controladores: maneja la replicación de aplicaciones administradas por controladores de replicación.
• Programador: rastrea la utilización de recursos en el clúster y asigna las cargas de trabajo en consecuencia.

Nodo Kubernetes

El nodo Kubernetes son servidores de trabajo responsables de ejecutar pods.

Los componentes principales de un nodo son:

• Docker: un demonio que ejecuta contenedores de aplicaciones definidos en pods.
• Kubelet: una unidad de control para pods en un sistema local.
• Kube-proxy: un proxy de red que garantiza el enrutamiento correcto para los servicios de Kubernetes.

Instalación

En esta guía, crearemos un clúster de 3 nodos utilizando servidores CentOS 7:

• 1 maestro de Kubernetes (maestro de kube)
• 2 nodos de Kubernetes (kube-node1, kube-node2)

Puede agregar tantos nodos adicionales como desee más adelante siguiendo el mismo procedimiento de instalación para los nodos de Kubernetes.

Todos los nodos

Configurar nombres de host y /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

Deshabilitar Firewalld:

systemctl disable firewalld
systemctl stop firewalld

Maestro Kubernetes

Instalar paquetes maestros de Kubernetes:

yum install etcd kubernetes-master

Configuración:

# /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"

Iniciar Etcd:

systemctl start etcd

Instale y configure la estructura de red de superposición de franela (esto es necesario para que los contenedores que se ejecutan en diferentes servidores puedan verse):

yum install flannel

Cree un archivo de configuración de franela ( flannel-config.json):

{
  "Network": "10.20.0.0/16",
  "SubnetLen": 24,
  "Backend": {
    "Type": "vxlan",
    "VNI": 1
  }  
}

Establezca la configuración de franela en el servidor Etcd:

etcdctl set coreos.com/network/config < flannel-config.json

Apunte Franela al servidor Etcd:

# /etc/sysconfig/flanneld
FLANNEL_ETCD="http://kube-master:2379"

Habilite los servicios para que comiencen en el arranque:

systemctl enable etcd
systemctl enable kube-apiserver
systemctl enable kube-controller-manager
systemctl enable kube-scheduler
systemctl enable flanneld

Reiniciar el servidor.

Nodo Kubernetes

Instalar paquetes de nodos Kubernetes:

yum install docker kubernetes-node

Los siguientes dos pasos configurarán Docker para usar overlayfs para un mejor rendimiento. Para obtener más información, visite esta publicación de blog :

Elimine el directorio de almacenamiento de docker actual:

systemctl stop docker
rm -rf /var/lib/docker

Cambiar archivos de configuración:

# /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

Configure kube-node1 para usar nuestro maestro configurado previamente:

# /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"

Instale y configure el tejido de red de superposición de franela (nuevamente, esto es necesario para que los contenedores que se ejecutan en diferentes servidores puedan verse):

yum install flannel

Apunte Franela al servidor Etcd:

# /etc/sysconfig/flanneld
FLANNEL_ETCD="http://kube-master:2379"

Habilitar servicios:

systemctl enable docker
systemctl enable flanneld
systemctl enable kubelet
systemctl enable kube-proxy

Reinicia el servidor.

Pon a prueba tu servidor Kubernetes

Después de que todos los servidores se hayan reiniciado, verifique si su clúster de Kubernetes está 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

Ejemplo: Implementar una cuadrícula de selenio usando Kubernetes

Selenium es un marco para automatizar navegadores con fines de prueba. Es una herramienta poderosa del arsenal de cualquier desarrollador web.

Selenium grid permite la ejecución remota escalable y paralela de pruebas a través de un grupo de nodos Selenium que están conectados a un concentrador Selenium central.

Dado que los nodos Selenium no tienen estado y la cantidad de nodos que ejecutamos es flexible, dependiendo de nuestras cargas de trabajo de prueba, esta es una aplicación candidata perfecta para implementarse en un clúster de Kubernetes.

En la siguiente sección, implementaremos una cuadrícula que consta de 5 contenedores de aplicaciones:

• 1 concentrador Selenium central que será el punto final remoto al que se conectarán nuestras pruebas.
• 2 nodos Selenium que ejecutan Firefox.
• 2 nodos de selenio con Chrome.

Estrategia de implementación

Para administrar automáticamente la replicación y la recuperación automática, crearemos un controlador de replicación de Kubernetes para cada tipo de contenedor de aplicaciones que enumeramos anteriormente.

Para proporcionar a los desarrolladores que ejecutan pruebas un punto final de concentrador Selenium estable, crearemos un servicio Kubernetes conectado al controlador de replicación del concentrador.

Cubo de selenio

Controlador de replicación

# 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

Despliegue:

[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

Aquí podemos ver que Kubernetes ha colocado mi contenedor de concentrador de selenio en kube-node2.

Servicio

# 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

Despliegue:

[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

Después de implementar el servicio, será accesible desde:

• Cualquier nodo de Kubernetes, a través de la IP virtual 10.254.124.73 y el puerto 4444.
• Redes externas, a través de las IP públicas de los nodos de Kubernetes, en el puerto 30000.

(utilizando la IP pública de otro nodo de Kubernetes)

Nódulos de selenio

Controlador de replicación de nodo de 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"

Despliegue:

Vuelva a colocar replace_with_service_ipen selenium-node-firefox-rc.yamlel centro de servicio de IP real selenio, en este 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

Como podemos ver, Kubernetes ha creado 2 réplicas selenium-firefox-nodey las ha distribuido a través del clúster. Pod selenium-node-firefox-lc6qtestá en kube-node2, mientras que pod selenium-node-firefox-y9qjpestá en kube-node1.

Repetimos el mismo proceso para nuestros nodos Selenium Chrome.

Controlador de replicación de nodo de 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"

Despliegue:

[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

Terminando

En esta guía, hemos configurado un pequeño grupo de Kubernetes de 3 servidores (1 controlador maestro + 2 trabajadores).

Utilizando pods, RC y un servicio, hemos implementado con éxito un Selenium Grid que consta de un concentrador central y 4 nodos, lo que permite a los desarrolladores ejecutar 4 pruebas de Selenium concurrentes a la vez en el clúster.

Kubernetes programó automáticamente los contenedores en todo el clúster.

Autocuración

Kubernetes reprograma automáticamente los pods a servidores en buen estado si uno o más de nuestros servidores se caen. En mi ejemplo, kube-node2 está ejecutando actualmente el pod de concentrador Selenium y 1 pod de 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  

Simularemos la falla del servidor cerrando kube-node2. Después de un par de minutos, debería ver que los contenedores que se estaban ejecutando en kube-node2 se han reprogramado para kube-node1, lo que garantiza una interrupción mínima del servicio.

[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

Escalando su rejilla de selenio

Escalar su Selenium Grid es muy fácil con Kubernetes. Imagina que en lugar de 2 nodos de Firefox, me gustaría ejecutar 4. El escalado se puede hacer con un solo 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