如何在kubernetes中运行docker image从另一个启动并传递参数

Question

我有两个停靠的应用程序，需要在kubernetes中运行。

以下是需要实现的场景。

Docker-1，这是flask应用程序。

Docker-2是python脚本，它将从Docker-1获取输入并执行，并且需要在Docker-1容器的共享卷中写入一些文件。

下面是flask web-app的代码。

from flask import Flask, request, Response, jsonify
app = Flask(__name__)

@app.route('/')
def root():
  return "The API is working fine"

@app.route('/run-docker')
def run_docker_2():
   args = "input_combo"
   query = <sql query>
   <initiate the docker run and pass params>
   exit
   #No return message need run as async

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0', port=8080, threaded=True)

Docker文件

FROM ubuntu:latest
MAINTAINER Abhilash KK "abhilash.kk@searshc.com"
RUN apt-get update -y
RUN apt-get install -y python-pip python-dev build-essential python-tk
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
ENTRYPOINT ["/usr/bin/python"]
CMD ["app.py"]

requirements.txt

flask

第二个docker的Python脚本。start_docker.py

import sys

input_combo = sys.argv[1]
query = sys.argv[2]

def function_to_run(input_combination,query):
    #starting the model final creating file

function_to_run(input_combo, query)

Docker文件2

FROM python

COPY . /script
WORKDIR /script

CMD ["python", "start_docker.py"]

请帮助我连接到docker图像。或者让我知道实现这个问题的任何其他方法。基本需求是将一条消息添加到某个队列中，该队列按时间间隔监听并以FIFO方式启动进程。

GCP服务中启动异步作业的任何其他方法都将从客户端获取输入，并创建一个可从web-app python访问的文件。

Answer 1

首先，创建一个运行Docker-1应用程序的Pod。然后使用Kubernetes python client生成第二个pod "Docker-2“。您可以在pods之间共享卷，以便将数据返回到Docker1。在我的代码示例中，我使用了一个host_path卷，但您需要确保两个pod位于同一节点上。我确实添加了该代码以提高可读性。

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: docker1
  labels:
    app: docker1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: docker1
  template:
    metadata:
      labels:
        app: docker1
    spec:
      containers:
      - name: docker1
        image: abhilash/docker1
        ports:
        - containerPort: 8080
        volumeMounts:
        - mountPath: /shared
          name: shared-volume
      volumes:
      - name: shared-volume
        hostPath:
          path: /shared

run_docker_2处理程序的代码：

from kubernetes import client, config

...

args = "input_combo"
config.load_incluster_config()
pod = client.V1Pod()
pod.metadata = client.V1ObjectMeta(name="docker2")
container = client.V1Container(name="docker2")
container.image = "abhilash/docker2"
container.args = [args]
volumeMount = client.V1VolumeMount(name="shared", mount_path="/shared")
container.volume_mounts = [volumeMount]
hostpath = client.V1HostPathVolumeSource(path = "/shared")
volume = client.V1Volume(name="shared")
volume.host_path = hostpath
spec = client.V1PodSpec(containers = [container])
spec.volumes = [volume]
pod.spec = spec
v1.create_namespaced_pod(namespace="default", body=pod)
return "OK"

读取返回结果的处理程序：

@app.route('/read-results')
def run_read():
   with open("/shared/results.data") as file:
      return file.read()

请注意，添加watcher以等待pod完成作业，然后执行一些清理操作(例如，删除pod )可能很有用。

Answer 2

据我所知，你会想要所谓的"sidecar pattern"，你可以在一个pod和share a volume中运行multiple containers，例如：

apiVersion: v1
kind: Pod
metadata:
  name: www
spec:
  containers:
  - name: nginx
    image: nginx
    volumeMounts:
    - mountPath: /srv/www
      name: www-data
      readOnly: true
  - name: git-monitor
    image: kubernetes/git-monitor
    env:
    - name: GIT_REPO
      value: http://github.com/some/repo.git
    volumeMounts:
    - mountPath: /data
      name: www-data
  volumes:
  - name: www-data
    emptyDir: {}

您还可以从了解Kubernetes如何工作的基础知识中获益：Kubernetes Basics