I tried moving the container with Hatoba

Hello everyone. This is an article from the third day of Fujitsu Cloud Technologies Advent Calendar 2019.

At first

Nifukura provides a container service called Hatoba. Click here for service introductions.

Hatoba is a service provided by Nifukura that makes it easy to build and manage Kubernetes clusters. The clusters we build at Hatoba are managed by Nifukura. The standard operation in Kubernetes allows containerized applications to be deployed on a cluster. Today, we're going to use this service to deploy containers.

Preparation

We will create an environment for operation on Nifukura. In this article, we will use VMware Photon OS 3.0. First of all, let's make docker work. From the Nifukura Control Panel, select VMware Photon OS 3.0 to create a server. When it starts, connect with ssh and create an environment where docker works.

systemctl start docker

Make sure the dockre command works properly.

docker --version

Let's also log in.

docker login

Prepare the application

Create a directory to store the application.

mkdir demo-app
cd demo-app

Make a simple application to make a container. It is implemented using a framework called Python's flask.

mkdir src
vi src/app.py

Since there was a minimal application example, we will use it.

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return "Hello World!"

if __name__ == '__main__':
    app.run()

Prepare the container

Prepare a container to run the application you created. Make a Dockerfile where Flask will work in a python container.

vi Dockerfile

FROM python:3.6
RUN pip install Flask
ARG project_dir=/projects/
ADD src/app.py $project_dir
WORKDIR $project_dir
CMD flask run --host 0.0.0.0 --port 5000

Check the operation of the container.

Create a container and see how it works.

docker build -t demo-app .
docker run -d -p 5000:5000 demo-app

Try connecting to the container you started.

curl -s http://127.0.0.1:5000

「Hello world!」 was displayed.

Register the created container with DockerHub

Register the container with DockerHub.

docker image tag demo-app <DockerID>/demo-app:v1
docker image push <DockerID>/demo-app:v1

Create a cluster

Now, let's create a Kubernetes environment to make this container work. Log in to Nifukura and select Hatoba.

Select Firewall from the left menu to keep the ports you need for access open:

Select a cluster from the left menu to create a cluster. When you select a cluster, the following screen is displayed.

To create a cluster, click the Create Cluster button.

Enter and select the necessary items and click the [To set up node pool] button.

Enter and select the necessary items and click the [Confirm] button.

Confirm the contents and click the [Create] button.

When it is launched successfully, you will see the above screen.

Try running kubectl

To get started, install the command.

tdnf -y install kubernetes-kubectl-extras
ln -s /opt/vmware/kubernetes/linux/amd64/kubectl /usr/local/bin

Next, prepare to use kubectl. Register cluster credentials for the connection. Select the cluster from the Control Panel and select Credential View.

Copy the displayed credentials and create a ~/.kube/config.

mkdir ~/.kube
vi  ~/.kube/config

Check if kubectl works properly.

kubectl get nodes

If you can get the information of the created node, you are done.

Register your application

Register the container in the created cluster. The definition file of the application to be registered is called

vi demo.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-flask
  labels:
    app: app-flask
spec:
  replicas: 3
  selector:
    matchLabels:
      app: app-flask
  template:
    metadata:
      labels:
        app: app-flask
        version: v1
    spec:
      containers:
        - name: app-flask
          image: <DockerID>/demo-app:v1
          command: ["flask"]
          args:
            - "run"
            - "--host"
            - "0.0.0.0"
            - "--port"
            - "5000"
          ports:
            - containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
  name: app-flask
spec:
  type: NodePort
  selector:
    app: app-flask
  ports:
    - protocol: TCP
      port: 5000
      name: app-flask
      nodePort: 31500

Register your application.

kubectl apply -f demo.yaml --record

Try to access it

View the node pool and check the configured global IP from the control panel, and make the connection as if you checked locally.

# curl -s http://<PodのIPアドレス>:31500

「Hello world!」 Did you see that?

Conclusion

What do you think? With Hatoba, it's easy to try out Kubernetes.

Tomorrow will be an extension of @tmtms's MySQL Parameters.