A LoadBalancer translates to a network load balancer. You can configure multiple ports for this e.g. 80 and 443. Then your application must handle the TLS part.

The ingress resource creates an HTTP(S) LB

From the GKE perspective you can try to configure Ingress resource with HTTPS enabled:

Steps:

• Create a basic flask app inside a pod (for example purposes only)
• Expose an app via service object of type nodePort
• Create a certificate
• Create an Ingress resource
• Test
• Additional information (added by EDIT)

Create a basic flask app inside a pod (for example purposes only)

Below is a flask script which will respond with <h1>Hello!</h1>:

from flask import Flask

app = Flask(__name__)
@app.route("/")

def index():
    return "<h1>Hello!</h1>"

if __name__ == "__main__":
    from waitress import serve
    serve(app, host="0.0.0.0", port=8080)

By default it will respond on port 8080.

Link to an answer with above script.

Expose an app via service object of type nodePort

Assuming that deployment is configured correctly with working app inside, you can expose it via service object type of nodePort with following YAML definition:

apiVersion: v1
kind: Service
metadata:
  name: flask-service
spec:
  type: NodePort
  selector:
    app: ubuntu
  ports:
  - name: flask-port 
    protocol: TCP
    port: 80
    targetPort: 8080 

Please make sure that:

• selector is configured correctly
• targetPort is pointing to port which is app is running on

Create a certificate

For Ingress object to work with HTTPS you will need to provide a certificate. You can create it with GKE official documentation on: Cloud.google.com: Managed certificates

Be aware of a fact that you will need a domain name to do that.

Create an Ingress resource

Below is an example Ingress resource which will point your requests to your flask application:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: flask-ingress
  annotations:
    networking.gke.io/managed-certificates: flask-certificate 
    kubernetes.io/ingress.global-static-ip-name: flask-static-ip
spec:
  rules:
  - host: DOMAIN.NAME
    http:
      paths:
      - path: /
        backend:
          serviceName: flask-service
          servicePort: flask-port

Please take a specific look on part of YAML definition below and change accordingly to your case:

    networking.gke.io/managed-certificates: flask-certificate 
    kubernetes.io/ingress.global-static-ip-name: flask-static-ip

Please wait for everything to configure correctly.

After that you will have access to your application by domain.name with ports:

• 80(http)
• 443(https)

Currently the Ingress only supports a single TLS port, 443, and assumes TLS termination.

-- Kubernetes.io: Ingress TLS

Test

You can check if above steps are configured correctly by:

• entering https://DOMAIN.NAME in your web browser and check if it responds with Hello with HTTPS enabled
• using a tool curl -v https://DOMAIN.NAME.

Please let me know if this solution works for you.

Additional information (added by EDIT)

You can try to configure service object of type LoadBalancer which will be operate at layer 4 as @Florian said in his answer.

Please refer to official documentation: Kubernetes.io: Create external load balancer

You can also use Nginx Ingress controller and either:

• Expose TCP/UDP service by following: Kubernetes.github.io: Ingress nginx: Exposing tcp udp services which will operating at L4.
• Create an Ingress resource that will have SSL Passthrough configured by following: Kubernetes.github.io: Ingress nginx: Ssl passthrough