问在"gcloud构建提交.“之后，烧瓶应用程序部署失败(活性探测失败)

EN

Name:         flask-676d5dd999-cf6kt
Namespace:    default
Priority:     0
Node:         gke-addition-app-default-pool-89aab4fe-3l1q/10.140.0.3
Start Time:   Thu, 11 Nov 2021 19:06:24 +0800
Labels:       app.kubernetes.io/managed-by=gcp-cloud-build-deploy
              component=flask
              pod-template-hash=676d5dd999
Annotations:  <none>
Status:       Running
IP:           10.24.0.25
IPs:
  IP:           10.24.0.25
Controlled By:  ReplicaSet/flask-676d5dd999
Containers:
  flask:
    Container ID:   containerd://5459b747e1d44046d283a46ec1eebb625be4df712340ff9cf492d5583a4d41d2
    Image:          gcr.io/peerless-garage-330917/addition-app-flask:latest
    Image ID:       gcr.io/peerless-garage-330917/addition-app-flask@sha256:b45d25ffa8a0939825e31dec1a6dfe84f05aaf4a2e9e43d35084783edc76f0de
    Port:           8000/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 12 Nov 2021 17:24:14 +0800
    Last State:     Terminated
      Reason:       Error
      Exit Code:    139
      Started:      Fri, 12 Nov 2021 17:17:06 +0800
      Finished:     Fri, 12 Nov 2021 17:19:06 +0800
    Ready:          False
    Restart Count:  222
    Limits:
      cpu:  1
    Requests:
      cpu:        400m
    Liveness:     http-get http://:8000/health delay=120s timeout=1s period=5s #success=1 #failure=3
    Readiness:    http-get http://:8000/ready delay=120s timeout=1s period=5s #success=1 #failure=3
    Environment:  <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-s97x5 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             False 
  ContainersReady   False 
  PodScheduled      True 
Volumes:
  default-token-s97x5:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-s97x5
    Optional:    false
QoS Class:       Burstable
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type     Reason     Age                     From     Message
  ----     ------     ----                    ----     -------
  Warning  Unhealthy  9m7s (x217 over 21h)    kubelet  (combined from similar events): Liveness probe failed: Get "http://10.24.0.25:8000/health": read tcp 10.24.0.1:48636->10.24.0.25:8000: read: connection reset by peer
  Warning  BackOff    4m38s (x4404 over 22h)  kubelet  Back-off restarting failed container

apiVersion: v1
kind: Service
metadata:
  name: ui
spec:
  type: LoadBalancer
  selector:
    app: react
    tier: ui
  ports:
    - port: 8080
      targetPort: 8080
---
apiVersion: v1
kind: Service
metadata: 
  name: flask
spec:
  type: ClusterIP
  selector:
    component: flask
  ports:
    - port: 8000
      targetPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask
spec:
  replicas: 1
  selector:
    matchLabels:
      component: flask
  template:
    metadata:
      labels:
        component: flask
    spec:
      containers:
        - name: flask
          image: gcr.io/peerless-garage-330917/addition-app-flask:latest
          imagePullPolicy: "Always"
          resources:
            limits:
              cpu: "1000m"
            requests:
              cpu: "400m"
          livenessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 30
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /ready
              port: 8000
            initialDelaySeconds: 30
            periodSeconds: 5
          ports:
            - containerPort: 8000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ui
spec:
  replicas: 1
  selector:
    matchLabels:
      app: react
      tier: ui
  template:
    metadata:
      labels:
        app: react
        tier: ui
    spec:
      containers:
        - name: ui
          image: gcr.io/peerless-garage-330917/addition-app-nginx:latest
          imagePullPolicy: "Always"
          resources:
            limits:
              cpu: "1000m"
            requests:
              cpu: "400m"
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 5
          ports:
            - containerPort: 8080

# we will be creating these services
services:
  flask:
    # Note that we are building from our current terminal directory where our Dockerfile is located, we use .
    build: . 
    # naming our resulting container
    container_name: flask
    # publishing a port so that external services requesting port 8000 on your local machine
    # are mapped to port 8000 on our container
    ports:
      - "8000:8000"

  nginx: 
    # Since our Dockerfile for web-server is located in react-app foler, our build context is ./react-app
    build: ./react-app
    container_name: nginx
    ports:
      - "8080:8080"

# first building react project, using node base image
FROM node:10 as build-stage

# setting working dir inside container
WORKDIR /react-app

# required to install packages
COPY package*.json ./

# installing npm packages
RUN npm install

# copying over react source material
COPY src ./src

# copying over further react material
COPY public ./public

# copying over our nginx config file
COPY addition_container_server.conf ./

# creating production build to serve through nginx
RUN npm run build

# starting second, nginx build-stage
FROM nginx:1.15

# removing default nginx config file
RUN rm /etc/nginx/conf.d/default.conf

# copying our nginx config
COPY --from=build-stage /react-app/addition_container_server.conf /etc/nginx/conf.d/

# copying production build from last stage to serve through nginx
COPY --from=build-stage /react-app/build/ /usr/share/nginx/html

# exposing port 8080 on container
EXPOSE 8080

CMD ["nginx", "-g", "daemon off;"]

server {

    listen 8080;

    # location of react build files
    root /usr/share/nginx/html/;

    # index html from react build to serve
    index index.html;

    # ONLY KUBERNETES RELEVANT: endpoint for health checkup
    location /health {
        return 200 "health ok";
    }

    # ONLY KUBERNETES RELEVANT: endpoint for readiness checkup
    location /ready {
        return 200 "ready";
    }

    # html file to serve with / endpoint
    location / {
            try_files $uri /index.html;
    }
    
    # proxing under /api endpoint
    location /api {
            client_max_body_size 10m;
            add_header 'Access-Control-Allow-Origin' http://<NGINX_SERVICE_ENDPOINT>:8080;
            proxy_pass http://flask:8000/;
    }
}

...
insertCalculation(event, calculation){
  /*
    Making a POST request via a fetch call to Flask API with numbers of a
    calculation we want to insert into DB. Making fetch call to web server
    IP with /api/insert_nums which will be reverse proxied via Nginx to the
    Application (Flask) server.
  */
    event.preventDefault();

    fetch('http://<NGINX_SERVICE_ENDPOINT>:8080/api/insert_nums', {method: 'POST',
                                                    mode: 'cors',
                                                    headers: {
                                                    'Content-Type' : 'application/json'
                                                    },
                                                    body: JSON.stringify(calculation)}
     ).then((response) => {
...
getHistory(event){
    /*
        Making a GET request via a fetch call to Flask API to retrieve calculations history.
    */

    event.preventDefault()

    fetch('http://<NGINX_SERVICE_ENDPOINT>:8080/api/data', {method: 'GET',
                                             mode: 'cors'
                                          }
    ).then(response => {
...

# using base image
FROM python:3.8

# setting working dir inside container
WORKDIR /addition_app_flask

# adding run.py to workdir
ADD run.py .

# adding config.ini to workdir
ADD config.ini .

# adding requirements.txt to workdir
ADD requirements.txt .

# installing flask requirements
RUN pip install -r requirements.txt

# adding in all contents from flask_app folder into a new flask_app folder
ADD ./flask_app ./flask_app

# exposing port 8000 on container
EXPOSE 8000

# serving flask backend through uWSGI server
CMD [ "python", "run.py" ]

from gevent.pywsgi import WSGIServer
from flask_app.app import app

# As flask is not a production suitable server, we use will
# a WSGIServer instance to serve our flask application. 
if __name__ == '__main__':  
    WSGIServer(('0.0.0.0', 8000), app).serve_forever()

from flask import Flask, request, jsonify
from flask_app.storage import insert_calculation, get_calculations

app = Flask(__name__)

@app.route('/')
def index():
    return "My Addition App", 200

@app.route('/health')
def health():
    return '', 200

@app.route('/ready')
def ready():
    return '', 200

@app.route('/data', methods=['GET'])
def data():
    '''
        Function used to get calculations history
        from Postgres database and return to fetch call in frontend.
    :return: Json format of either collected calculations or error message
    '''

    calculations_history = []

    try:
        calculations = get_calculations()
        for key, value in calculations.items():
            calculations_history.append(value)
    
        return jsonify({'calculations': calculations_history}), 200
    except:
        return jsonify({'error': 'error fetching calculations history'}), 500

@app.route('/insert_nums', methods=['POST'])
def insert_nums():
    '''
        Function used to insert a calculation into our postgres
        DB. Operands of operation received from frontend.
    :return: Json format of either success or failure response.
    '''

    insert_nums = request.get_json()
    firstNum, secondNum, answer = insert_nums['firstNum'], insert_nums['secondNum'], insert_nums['answer']

    try:
        insert_calculation(firstNum, secondNum, answer)
        return jsonify({'Response': 'Successfully inserted into DB'}), 200
    except:
        return jsonify({'Response': 'Unable to insert into DB'}), 500