<p>Looking at a client library for the Kubernetes API, I couldn't find an option to retrieve the output returned from a command execution inside the container. If we take the following python code example, can I get the actual output returned from the container start command?</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-html lang-html prettyprint-override"><code># Copyright 2016 The Kubernetes Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Creates, updates, and deletes a job object.
"""

from os import path

import yaml

from kubernetes import client, config

JOB_NAME = "pi"


def create_job_object():
    # Configureate Pod template container
    container = client.V1Container(
        name="pi",
        image="perl",
        command=["perl", "-Mbignum=bpi", "-wle", "print bpi(2000)"])
    # Create and configurate a spec section
    template = client.V1PodTemplateSpec(
        metadata=client.V1ObjectMeta(labels={"app": "pi"}),
        spec=client.V1PodSpec(restart_policy="Never", containers=[container]))
    # Create the specification of deployment
    spec = client.V1JobSpec(
        template=template,
        backoff_limit=4)
    # Instantiate the job object
    job = client.V1Job(
        api_version="batch/v1",
        kind="Job",
        metadata=client.V1ObjectMeta(name=JOB_NAME),
        spec=spec)

    return job


def create_job(api_instance, job):
    api_response = api_instance.create_namespaced_job(
        body=job,
        namespace="default")
    print("Job created. status='%s'" % str(api_response.status))


def update_job(api_instance, job):
    # Update container image
    job.spec.template.spec.containers[0].image = "perl"
    api_response = api_instance.patch_namespaced_job(
        name=JOB_NAME,
        namespace="default",
        body=job)
    print("Job updated. status='%s'" % str(api_response.status))


def delete_job(api_instance):
    api_response = api_instance.delete_namespaced_job(
        name=JOB_NAME,
        namespace="default",
        body=client.V1DeleteOptions(
            propagation_policy='Foreground',
            grace_period_seconds=5))
    print("Job deleted. status='%s'" % str(api_response.status))


def main():
    # Configs can be set in Configuration class directly or using helper
    # utility. If no argument provided, the config will be loaded from
    # default location.
    config.load_kube_config()
    batch_v1 = client.BatchV1Api()
    # Create a job object with client-python API. The job we
    # created is same as the `pi-job.yaml` in the /examples folder.
    job = create_job_object()

    create_job(batch_v1, job)

    update_job(batch_v1, job)

    delete_job(batch_v1)


if __name__ == '__main__':
    main()</code></pre>
</div>
</div>
</p>

<p>I've only attached an example code from the Python client library but I've got a specific task in which I need the actual output after the job has been completed. I need that output in the API response though, because I will need to access that programatically.</p>

<p>So basically: </p>

<ol>
<li><p>Run job in Python</p></li>
<li><p>Job finishes</p></li>
<li><p>Get output from container inside job (output from starting command)</p></li>
</ol>

thatguyjono
<p>This code will print the log (stdout output) <em>after</em> the job has completed:</p>
<pre class="lang-py prettyprint-override"><code>from kubernetes import client, config


JOB_NAMESPACE = &quot;default&quot;
JOB_NAME = &quot;pi&quot;


def main():
    config.load_kube_config()

    batch_v1 = client.BatchV1Api()

    job_def = batch_v1.read_namespaced_job(name=JOB_NAME, namespace=JOB_NAMESPACE)
    controllerUid = job_def.metadata.labels[&quot;controller-uid&quot;]

    core_v1 = client.CoreV1Api()

    pod_label_selector = &quot;controller-uid=&quot; + controllerUid
    pods_list = core_v1.list_namespaced_pod(namespace=JOB_NAMESPACE, label_selector=pod_label_selector, timeout_seconds=10)

    # Notice that:
    # - there are more parameters to limit size, lines, and more - see
    #   https://github.com/kubernetes-client/python/blob/master/kubernetes/docs/CoreV1Api.md#read_namespaced_pod_log
    # - the logs of the 1st pod are returned (similar to `kubectl logs job/&lt;job-name&gt;`)
    # - assumes 1 container in the pod
    pod_name = pods_list.items[0].metadata.name
    try:
        # For whatever reason the response returns only the first few characters unless
        # the call is for `_return_http_data_only=True, _preload_content=False`
        pod_log_response = core_v1.read_namespaced_pod_log(name=pod_name, namespace=JOB_NAMESPACE, _return_http_data_only=True, _preload_content=False)
        pod_log = pod_log_response.data.decode(&quot;utf-8&quot;)
        print(pod_log)
    except client.rest.ApiException as e:
        print(&quot;Exception when calling CoreV1Api-&gt;read_namespaced_pod_log: %s\n&quot; % e)


if __name__ == '__main__':
    main()
</code></pre>
