Docker technology is a containerization mechanism to run images as containers. It also allows us to build images, upload into a secure registry, and run the images available at the docker registry. Refer to our article to get a quick start on docker<\/a> containers.<\/p>\n Further to the definition, this section shows how Kubernetes executes workloads (or applications) through docker containers. <\/p>\n A typical Kubernetes cluster, as shown in the figure below, consists of a master node and one more worker nodes. The master node is also called as control-plane and hosts a Kube API server that receives requests to run applications that are divided into small units called POD. The POD is a minimal running unit that is managed by the master node. Into the POD, there goes in one or more containers running from the images built from the application which is to be executed.<\/p>\n Let us take an example of running a simple node JS application enabled by Express.<\/p>\n Here The application consists of a simple Express-based nodeJS application. The node JS has a start point It comes with a Dockerfile using which you can generate a Docker image. The application code also comes with Let us consider the image generated using the example application is jcg-nodejs:1.0.0. The below listing is the YAML to create the deployment:<\/p>\n Here the above YAML, shows that the deployment name is deployment-jcg and it has a POD specification for a single container (name: jcg-nodejs) based on the image jcg-nodejs:1.0.0 and the image itself exposes a port 3000,<\/p>\n When you create a deployment with the above YAML, the Kubernetes downloads the images jcg-nodejs:1.0.0 and runs it as a container. Once the POD is in running state, the node JS Application would be running at 3000. However, to access the application you need to create a service and access the POD through the service. Check Section 5. Execution to see a detailed way to deploy and see it in action. <\/p>\n This section illustrates the running of the sample application on a minikube version of Kubernetes (K8s). This section covers the installation of minikube, local registry, building the image, and finally running the container on the local minikube. These instructions assume Ubuntu Linux OS. Refer to the Kubernetes<\/a> site to know the instructions for other operating systems.<\/p>\n Step 1: Install Docker<\/p>\n sudo groupadd docker && sudo usermod -aG docker $USER Step 3: add the Minikube executable to your path<\/p>\n Step 4: Install kubectl. Reference: Kubernetes<\/a>[ulp id=’6PVIvOz3kDbYmNRn’]<\/p>\n Step 5: Start the minikube using Docker as the driver<\/p>\n Step 1: Upload the example code to the minikube host to a place say, Step 2: Build the image.<\/p>\n Deploy to Kubernetes is using the YAML which comes along with the application. For more information about deployments refer to the Kubernetes<\/a> documentation.<\/p>\n Output:<\/em><\/span><\/p>\n Check if pods are running.<\/p>\n Output:<\/em><\/span><\/p>\n To access the hello-minikube Deployment, expose it as a Service<\/p>\n Get the URL to access the application.<\/p>\n Output:<\/em><\/span><\/p>\n Access the application using a browser at the URL shown in the above step.<\/p>\n2. How Kubernetes uses docker<\/h2>\n
![\"Docker](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/08\/Fig1-Introduction-final.jpg\")
kubectl<\/code> deploys an application through a deployment. When a deployment is created the K8s create a POD based on a given Docker image. When the Kubernetes master issues a command to the worker nodes to create a POD, the worker node downloads the said docker image and runs the same as a container.<\/p>\n3. The Application<\/h2>\n
app.js<\/code> which the endpoint “\/” which returns a text – Welcome to the JCG tutorial for Kubernetes Docker Integration. You can start the application by simply executing node app.js<\/code> provided you have Node version 12 is installed.<\/p>\ndeployment-jcg.yaml<\/code> which can be used to deploy the image, generated using the above Dockerfile<\/code>, on to the Kubernetes cluster.![\"Docker](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/08\/Application-final.jpg\")
4. K8s Deployment<\/h2>\n
\napiVersion: apps\/v1\nkind: Deployment\nmetadata:\n name: deployment-jcg\n labels:\n app: nodejs\nspec:\n replicas: 1\n selector:\n matchLabels:\n app: nodejs\n template:\n metadata:\n labels:\n app: nodejs\n spec:\n containers:\n - name: jcg-nodejs\n image: jcg-nodejs:1.0.0\n ports:\n - containerPort: 3000\n<\/pre>\n<\/div>\n
5. Execution<\/h2>\n
5.1 Installation of Minikube<\/h3>\n
sudo apt install docker.io<\/pre>\n
\nStep 2: Download minikube<\/p>\ncurl -Lo minikube https:\/\/storage.googleapis.com\/minikube\/releases\/latest\/minikube-linux-amd64 \\\n && chmod +x minikube<\/pre>\n
sudo mkdir -p \/usr\/local\/bin\/\nsudo install minikube \/usr\/local\/bin\/<\/pre>\n
curl -LO \"https:\/\/storage.googleapis.com\/kubernetes-release\/release\/$(curl -s https:\/\/storage.googleapis.com\/kubernetes-release\/release\/stable.txt)\/bin\/linux\/amd64\/kubectl\"\nchmod +x .\/kubectl\nsudo mv .\/kubectl \/usr\/local\/bin\/kubectl<\/pre>\n
minikube start --driver=docker<\/pre>\n
![\"Docker](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/08\/MinikubeStart-final.jpg\")
5.2 Upload source code and build the image<\/h3>\n
\/home\/shiva\/jcg-nodejs<\/code><\/p>\n\ncd NodeJSExample\neval $(minikube docker-env)\ndocker build . --file Dockerfile --tag jcg-nodejs:1.0.0\n<\/pre>\n<\/p>\n
5.3. Deploy the application to the Kubernetes<\/h3>\n
kubectl apply -f deployment-jcg.yaml<\/pre>\n
\ndeployment.apps\/nginx-deployment created\n<\/pre>\n<\/p>\n
\nkubectl get pods\n<\/pre>\n
\nNAME READY STATUS RESTARTS AGE\ndeployment-jcg-6bdfc58f5f-2sbbb 1\/1 Running 0 48s\n<\/pre>\n
kubectl expose deployment deployment-jcg --type=NodePort --port=3000<\/pre>\n
minikube service deployment-jcg --url<\/pre>\n
http:\/\/172.17.0.4:31819\n<\/pre>\n
![\"Docker](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2020\/08\/ApplicationInBrowser-final.jpg\")