{"id":2608,"date":"2020-08-23T07:05:08","date_gmt":"2020-08-23T07:05:08","guid":{"rendered":"http:\/\/www.ruthtech.com\/?p=2608"},"modified":"2020-08-23T08:36:46","modified_gmt":"2020-08-23T08:36:46","slug":"setting-up-selenium-hub-in-kubernetes","status":"publish","type":"post","link":"https:\/\/www.ruthtech.com\/?p=2608","title":{"rendered":"Setting up Selenium Hub in Kubernetes"},"content":{"rendered":"

Setting up Selenium Hub in Kubernetes<\/strong>
\nThis tutorial assumes that you can write and set up a basic selenium test automation framework. This tutorial will focus on setting up selenium hub in kubernetes infrastructure, explaining some of the basic terminologies and how to set it up.<\/p>\n

Definitions –<\/strong><\/p>\n

    \n
  1. Kubernetes<\/strong> – is an open-source system for automating deployment, scaling, and management of containerized applications
    \nAnother definition that I like is – k8 is a portable, extensible, open-source platform for managing containerized workloads and services, that facilitates both declarative configuration and automation.<\/li>\n
  2. Cluster<\/strong> – A Kubernetes cluster consists of a set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node.
    \nThe worker node(s) host the Pods that are the components of the application workload. The control plane manages the worker nodes and the Pods in the cluster. As seen in the diagram below:<\/li>\n<\/ol>\n

    <\/p>\n

    Tools<\/strong> –<\/p>\n

      \n
    1. GitHub Repo<\/a> <\/span>–<\/li>\n
    2. IDE – (VS Code Suggested<\/a><\/span>)<\/li>\n<\/ol>\n

      Installation<\/strong>
      \nIn this tutorial we will be going through how to set up kubernetes on your local machine as well as in cloud – AWS and GC.<\/p>\n

        \n
      1. Local environment:<\/strong>
        \nInstall VSCode, install the Kubernetes plug and its dependencies and go through the steps below:<\/p>\n
          \n
        1. Brew – install here
          \n\/bin\/bash -c “$(curl -fsSL https:\/\/raw.githubusercontent.com\/Homebrew\/install\/master\/install.sh)”<\/em><\/li>\n
        2. VM: Hyperkit Driver – Install (Optional)\n
            \n
          1. brew install docker-machine-driver-hyperkit<\/em><\/li>\n
          2. sudo chown root:wheel ~\/.minikube\/bin\/docker-machine-driver-hyperkit<\/em><\/li>\n
          3. sudo chmod u+s ~\/.minikube\/bin\/docker-machine-driver-hyperkit<\/em><\/li>\n<\/ol>\n<\/li>\n
          4. Minikube – Installation link\n
              \n
            1. brew install minikube<\/em><\/li>\n
            2. sudo mv minikube \/usr\/local\/bin<\/em><\/li>\n<\/ol>\n<\/li>\n
            3. Kubernetes CLI –\n
                \n
              1. brew install kubernetes-cli (This is automatically installed with minikube)<\/em><\/li>\n<\/ol>\n<\/li>\n
              2. Kubectl Install here (Upgrade)\n
                  \n
                1. brew install kubectl<\/em><\/li>\n
                2. brew install kubectl 1.18.0<\/em><\/li>\n
                3. chmod +x .\/kubectl<\/em><\/li>\n
                4. sudo mv .\/kubectl \/usr\/local\/bin\/kubectl<\/em><\/li>\n
                5. Verify version – kubectl version –client<\/em><\/li>\n<\/ol>\n<\/li>\n
                6. Start Cluster\n
                    \n
                  1. minikube start (will automatically download hyperkit)<\/em><\/li>\n
                  2. minikube dashboard<\/em><\/li>\n<\/ol>\n<\/li>\n
                  3. Setting up Selenium Hub needed to run test in Kubernetes\n
                      \n
                    1. We need to create a deployment app in a deploy.yml file that has all the set up needed to create a selenium-hub. The file contains the following:\n
                        \n
                      1. The application version – appVersion<\/em><\/li>\n
                      2. What kind of app we wanna establish – Deployment<\/em><\/li>\n
                      3. The metadata to identify the pod. In this case we use – name<\/em><\/li>\n
                      4. The spec\n
                          \n
                        1. The spec has a template format, where we need to set up the image that needs to be deployed in the container.<\/em><\/li>\n
                        2. The name of the container and the port that we want to expose and for selenium we will be using the default – 4444<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                        3. To deploy a pod\n
                            \n
                          1. There are several ways to deploy or start a pod within the namespace of a cluster. We are going to deploy our pods directly from the file. Using the command:
                            \nKubectl create -f<\/em><\/li>\n
                          2. To get the list of the pods in the cluster, we are going to use the command:
                            \nKubectl get pods<\/em><\/li>\n
                          3. To get all the information about a particular pod or function, we are going to use the command:
                            \nKubectl describe pod <\/em><\/li>\n
                          4. You\u2019ll get the pod name from the metadata name tag or from the list provided from \u201ckubectl get pods\u201d<\/em><\/li>\n<\/ol>\n<\/li>\n
                          5. Set up Service to expose the application\n
                              \n
                            1. When the selenium-hub application is deployed, we need a way to expose the 4444 to other nodes that want to connect to the hub.<\/li>\n
                            2. So we create a service application and name it whatever you like but in this case I named it – service.yml<\/li>\n
                            3. The service.yml file contains the following with some explanation of the parameters mean.\n
                                \n
                              1. The apiVersion, as the name implies is the apiVersion provided by the Kubernetes team.<\/li>\n
                              2. What kind of app are we looking to set up; this kind is – Service<\/li>\n
                              3. Metadata – we need a way to identify the pod and within the metadata we have –\n
                                  \n
                                1. Name – The name of the pod.<\/li>\n
                                2. Label – We also add a label to identify the application, because the service is an application.<\/li>\n<\/ol>\n<\/li>\n
                                3. Spec – We also add the spec to provide more information on the application as well. The Service spec has the following –\n
                                    \n
                                  1. A selector – which is used to define the application that we want to expose its port to other services within the namespace or cluster.\n
                                      \n
                                    1. App – the name of the app that the service needs to select and expose its ports.<\/li>\n<\/ol>\n<\/li>\n
                                    2. Ports – The application identified in the selector has its ports and the new port(s) that we are going to map it to for other services to use as a point\/port of access\n
                                        \n
                                      1. Port -The original port of the application that the service is exposing its port and in this case its the selenium-hub which is 4444.<\/li>\n
                                      2. nodePort – we are using nodePort to expose the port of the application by mapping the new port. It is good practice to use ports in the 30000-39999 range.<\/li>\n
                                      3. Nodeport – We need to tell the service application to use nodeport.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                      4. Create a Replica Controller –\n
                                          \n
                                        1. We are going to use the replica controller to ensure that we have control over the pods lifecycle. The replica controller helps to ensure that the number of pods we declared and instantiated remains the same. Like in the replica.yml you\u2019ll notice that we declared 2 selenium-chrome to be live and running in the namespace or cluster.<\/li>\n
                                        2. In summary the replica controller will do these things for us –\n
                                            \n
                                          1. Create the replica controller kind with the number of browser nodes needed to stay alive, running and active.<\/li>\n
                                          2. Connect to the service to provide the bridge between the grid and the individual nodes.<\/li>\n<\/ol>\n<\/li>\n
                                          3. The replica.yml contains the following –\n
                                              \n
                                            1. apiVersion – By now you understand what the apiVersion is used for in the yml file.<\/li>\n
                                            2. Kind – The feature kind here is replica controller and in summary, is used to maintain the lifecycle of pods declared.<\/li>\n
                                            3. Metadata – because we need to identify the replica controller pod\n
                                                \n
                                              1. Name – we use the name of the pod to identify the pod via its metadata. The name in our replica.yml file is – selenium-rep<\/li>\n<\/ol>\n<\/li>\n
                                              2. Spec – Lets define the specification of the application\n
                                                  \n
                                                1. Replicas – As its name implies, it is used to determine the number of replicas of the pod that is needed to be up and running always.<\/li>\n<\/ol>\n<\/li>\n
                                                2. Selector – This is used to identify the application or container that needed to be selected for a particular action.\n
                                                    \n
                                                  1. \n
                                                      \n
                                                    1. App – The app in the case is the: selenium-chrome which is defined within the \u201ctemplate\u201d first<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                                    2. Please note that the replica controller does not consist of just these parameters, we are only declaring the ones that we need for this topic.
                                                      \nCreate the replica controller kind to determine the number of browser node needed.
                                                      \nConnect to the service to provide the bridge between the grid and the individual nodes<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                                    3. Run tests in the Selenium Hub.<\/span>\n
                                                        \n
                                                      1. To get the IP – there are several ways to get the IP, the one I recommend which will also be easier for you to remember is using the kubectl to describe the selenium-hub.<\/span>\n
                                                          \n
                                                        1. Kubectl describe pod selenium-hub<\/em><\/li>\n
                                                        2. All the information about the selenium-hub will be rendered. You want to pay attention to the value of the Node – minikube\/XXX.XX.XX.X<\/span><\/li>\n
                                                        3. The IP value will be listed as the value of Node<\/span><\/li>\n<\/ol>\n<\/li>\n
                                                        4. Selenium test suite –<\/span>\n
                                                            \n
                                                          1. The document assumes that you know how to run selenium tests remotely using the remote function provided by selenium.<\/span><\/li>\n
                                                          2. To run tests in the Kubernetes cluster; your remote url needs to be updated with the IP obtained from describing service.yml and the nodePort provided. For example \u21d2 http:\/\/XXX.XX.XX.X:30001\/wd\/hub<\/em><\/li>\n
                                                          3. Run your tests with your usual commands.<\/span><\/li>\n
                                                          4. TIP – Write a script to check that the hub\u2019s availability before running test – http:\/\/XXX.XX.XX.X:30001\/wd\/hub\/status<\/em><\/span><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                                          5. Quick Kubectl commands<\/span>\n
                                                              \n
                                                            1. Kubectl get pods<\/em><\/li>\n
                                                            2. Kubectl create -f <\/em><\/li>\n
                                                            3. Kubectl delete pod <\/em><\/li>\n
                                                            4. kubectl delete replicationcontroller selenium-rep<\/em><\/li>\n
                                                            5. kubectl delete deployment selenium-hub<\/em><\/li>\n
                                                            6. kubectl delete svc selenium-srv<\/em><\/li>\n
                                                            7. Kubectl describe<\/em> <function><\/span>\n
                                                                \n
                                                              1. Functions can be – deploy, svc – kubectl describe svc<\/span><\/li>\n
                                                              2. Kubectl describe pod kubectl describe replicationcontroller selenium-rep<\/span><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                                              3. Debugging<\/span>\n
                                                                  \n
                                                                1. Download VNC from Chrome<\/span><\/li>\n
                                                                2. Replace POD_NAME with the name of the pod you want to connect to.<\/span><\/li>\n
                                                                3. kubectl port-forward $POD_NAME 5900:5900<\/span><\/em><\/li>\n
                                                                4. Then connect to localhost:5900 with your VNC client using the password “secret”<\/span><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n<\/li>\n
                                                                5. Cloud Environment – Coming soon.<\/span><\/strong>\n
                                                                    \n
                                                                  1. Amazon EKS – Managed Kubernetes Service or <\/span><\/strong><\/li>\n
                                                                  2. Google Kubernetes Engine.<\/span><\/strong><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"

                                                                    Setting up Selenium Hub in Kubernetes This tutorial assumes that you can write and set up a basic selenium test […]<\/p>\n","protected":false},"author":1,"featured_media":2616,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[130,139],"tags":[136,145,146,153,155,141,144,154,151,150,156,131,152,137,157,143,142,148,149,147],"_links":{"self":[{"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/posts\/2608"}],"collection":[{"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=2608"}],"version-history":[{"count":7,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/posts\/2608\/revisions"}],"predecessor-version":[{"id":2635,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/posts\/2608\/revisions\/2635"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=\/wp\/v2\/media\/2616"}],"wp:attachment":[{"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2608"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2608"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ruthtech.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2608"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}