Add init containers to generate and play kube

Kubernetes has a concept of init containers that run and exit before
the regular containers in a pod are started. We added init containers
to podman pods as well. This patch adds support for generating init
containers in the kube yaml when a pod we are converting had init
containers. When playing a kube yaml, it detects an init container
and creates such a container in podman accordingly.
Note, only init containers created with the init type set to "always"
will be generated as the "once" option deletes the init container after
it has run and exited. Play kube will always creates init containers
with the "always" init container type.

Signed-off-by: Urvashi Mohnani <umohnani@redhat.com>

9 files changed, 300 insertions, 67 deletions

diff --git a/docs/source/markdown/podman-generate-kube.1.md b/docs/source/markdown/podman-generate-kube.1.md
index 2e00b58b6..2e9f68bf3 100644
--- a/docs/source/markdown/podman-generate-kube.1.md
+++ b/docs/source/markdown/podman-generate-kube.1.md
@@ -16,6 +16,9 @@ Volumes appear in the generated YAML according to two different volume types. Bi
 
 Potential name conflicts between volumes are avoided by using a standard naming scheme for each volume type. The *hostPath* volume types are named according to the path on the host machine, replacing forward slashes with hyphens less any leading and trailing forward slashes. The special case of the filesystem root, `/`, translates to the name `root`. Additionally, the name is suffixed with `-host` to avoid naming conflicts with *persistentVolumeClaim* volumes. Each *persistentVolumeClaim* volume type uses the name of its associated named volume suffixed with `-pvc`.
 
+Note that if an init container is created with type `once` and the pod has been started, the init container will not show up in the generated kube YAML as `once` type init containers are deleted after they are run. If the pod has only been created and not started, it will be in the generated kube YAML.
+Init containers created with type `always` will always be generated in the kube YAML as they are never deleted, even after running to completion.
+
 Note that the generated Kubernetes YAML file can be used to re-run the deployment via podman-play-kube(1).
 
 ## OPTIONS
diff --git a/docs/source/markdown/podman-play-kube.1.md b/docs/source/markdown/podman-play-kube.1.md
index 6af1bde1d..c170d6495 100644
--- a/docs/source/markdown/podman-play-kube.1.md
+++ b/docs/source/markdown/podman-play-kube.1.md
@@ -20,6 +20,8 @@ Currently, the supported Kubernetes kinds are:
 
 Only two volume types are supported by play kube, the *hostPath* and *persistentVolumeClaim* volume types. For the *hostPath* volume type, only the  *default (empty)*, *DirectoryOrCreate*, *Directory*, *FileOrCreate*, *File*, and *Socket* subtypes are supported. The *CharDevice* and *BlockDevice* subtypes are not supported. Podman interprets the value of *hostPath* *path* as a file path when it contains at least one forward slash, otherwise Podman treats the value as the name of a named volume. When using a *persistentVolumeClaim*, the value for *claimName* is the name for the Podman named volume.
 
+Note: When playing a kube YAML with init containers, the init container will be created with init type value `always`.
+
 Note: *hostPath* volume types created by play kube will be given an SELinux private label (Z)
 
 Note: If the `:latest` tag is used, Podman will attempt to pull the image from a registry. If the image was built locally with Podman or Buildah, it will have `localhost` as the domain, in that case, Podman will use the image from the local store even if it has the `:latest` tag.
diff --git a/libpod/container.go b/libpod/container.go
index 0986a0d80..a4bbb5dd0 100644
--- a/libpod/container.go
+++ b/libpod/container.go
@@ -1062,6 +1062,11 @@ func (c *Container) IsInfra() bool {
 	return c.config.IsInfra
 }
 
+// IsInitCtr returns whether the container is an init container
+func (c *Container) IsInitCtr() bool {
+	return len(c.config.InitContainerType) > 0
+}
+
 // IsReadOnly returns whether the container is running in read only mode
 func (c *Container) IsReadOnly() bool {
 	return c.config.Spec.Root.Readonly
diff --git a/libpod/kube.go b/libpod/kube.go
index fff040adb..812bb101b 100644
--- a/libpod/kube.go
+++ b/libpod/kube.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math/rand"
 	"os"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -220,8 +221,14 @@ func (p *Pod) podWithContainers(containers []*Container, ports []v1.ContainerPor
 	deDupPodVolumes := make(map[string]*v1.Volume)
 	first := true
 	podContainers := make([]v1.Container, 0, len(containers))
+	podInitCtrs := []v1.Container{}
 	podAnnotations := make(map[string]string)
 	dnsInfo := v1.PodDNSConfig{}
+
+	// Let's sort the containers in order of created time
+	// This will ensure that the init containers are defined in the correct order in the kube yaml
+	sort.Slice(containers, func(i, j int) bool { return containers[i].CreatedTime().Before(containers[j].CreatedTime()) })
+
 	for _, ctr := range containers {
 		if !ctr.IsInfra() {
 			// Convert auto-update labels into kube annotations
@@ -229,6 +236,8 @@ func (p *Pod) podWithContainers(containers []*Container, ports []v1.ContainerPor
 				podAnnotations[k] = v
 			}
 
+			isInit := ctr.IsInitCtr()
+
 			ctr, volumes, _, err := containerToV1Container(ctr)
 			if err != nil {
 				return nil, err
@@ -245,6 +254,10 @@ func (p *Pod) podWithContainers(containers []*Container, ports []v1.ContainerPor
 				ctr.Ports = ports
 				first = false
 			}
+			if isInit {
+				podInitCtrs = append(podInitCtrs, ctr)
+				continue
+			}
 			podContainers = append(podContainers, ctr)
 			// Deduplicate volumes, so if containers in the pod share a volume, it's only
 			// listed in the volumes section once
@@ -278,13 +291,14 @@ func (p *Pod) podWithContainers(containers []*Container, ports []v1.ContainerPor
 	return newPodObject(
 		p.Name(),
 		podAnnotations,
+		podInitCtrs,
 		podContainers,
 		podVolumes,
 		&dnsInfo,
 		hostNetwork), nil
 }
 
-func newPodObject(podName string, annotations map[string]string, containers []v1.Container, volumes []v1.Volume, dnsOptions *v1.PodDNSConfig, hostNetwork bool) *v1.Pod {
+func newPodObject(podName string, annotations map[string]string, initCtrs, containers []v1.Container, volumes []v1.Volume, dnsOptions *v1.PodDNSConfig, hostNetwork bool) *v1.Pod {
 	tm := v12.TypeMeta{
 		Kind:       "Pod",
 		APIVersion: "v1",
@@ -304,9 +318,10 @@ func newPodObject(podName string, annotations map[string]string, containers []v1
 		Annotations:       annotations,
 	}
 	ps := v1.PodSpec{
-		Containers:  containers,
-		Volumes:     volumes,
-		HostNetwork: hostNetwork,
+		Containers:     containers,
+		HostNetwork:    hostNetwork,
+		InitContainers: initCtrs,
+		Volumes:        volumes,
 	}
 	if dnsOptions != nil {
 		ps.DNSConfig = dnsOptions
@@ -323,6 +338,7 @@ func newPodObject(podName string, annotations map[string]string, containers []v1
 // for a single container.  we "insert" that container description in a pod.
 func simplePodWithV1Containers(ctrs []*Container) (*v1.Pod, error) {
 	kubeCtrs := make([]v1.Container, 0, len(ctrs))
+	kubeInitCtrs := []v1.Container{}
 	kubeVolumes := make([]v1.Volume, 0)
 	hostNetwork := true
 	podDNS := v1.PodDNSConfig{}
@@ -333,6 +349,8 @@ func simplePodWithV1Containers(ctrs []*Container) (*v1.Pod, error) {
 			kubeAnnotations[k] = v
 		}
 
+		isInit := ctr.IsInitCtr()
+
 		if !ctr.HostNetwork() {
 			hostNetwork = false
 		}
@@ -340,7 +358,11 @@ func simplePodWithV1Containers(ctrs []*Container) (*v1.Pod, error) {
 		if err != nil {
 			return nil, err
 		}
-		kubeCtrs = append(kubeCtrs, kubeCtr)
+		if isInit {
+			kubeInitCtrs = append(kubeInitCtrs, kubeCtr)
+		} else {
+			kubeCtrs = append(kubeCtrs, kubeCtr)
+		}
 		kubeVolumes = append(kubeVolumes, kubeVols...)
 
 		// Combine DNS information in sum'd structure
@@ -379,6 +401,7 @@ func simplePodWithV1Containers(ctrs []*Container) (*v1.Pod, error) {
 	return newPodObject(
 		strings.ReplaceAll(ctrs[0].Name(), "_", ""),
 		kubeAnnotations,
+		kubeInitCtrs,
 		kubeCtrs,
 		kubeVolumes,
 		&podDNS,
diff --git a/pkg/domain/entities/play.go b/pkg/domain/entities/play.go
index 77329e328..f630b3f24 100644
--- a/pkg/domain/entities/play.go
+++ b/pkg/domain/entities/play.go
@@ -51,6 +51,8 @@ type PlayKubePod struct {
 	ID string
 	// Containers - the IDs of the containers running in the created pod.
 	Containers []string
+	// InitContainers - the IDs of the init containers to be run in the created pod.
+	InitContainers []string
 	// Logs - non-fatal errors and log messages while processing.
 	Logs []string
 	// ContainerErrors - any errors that occurred while starting containers
diff --git a/pkg/domain/infra/abi/play.go b/pkg/domain/infra/abi/play.go
index c6d5dcc3d..87506f70c 100644
--- a/pkg/domain/infra/abi/play.go
+++ b/pkg/domain/infra/abi/play.go
@@ -304,76 +304,59 @@ func (ic *ContainerEngine) playKubePod(ctx context.Context, podName string, podY
 	}
 
 	containers := make([]*libpod.Container, 0, len(podYAML.Spec.Containers))
+	initContainers := make([]*libpod.Container, 0, len(podYAML.Spec.InitContainers))
 	cwd, err := os.Getwd()
 	if err != nil {
 		return nil, err
 	}
+
+	for _, initCtr := range podYAML.Spec.InitContainers {
+		// Init containers cannot have either of lifecycle, livenessProbe, readinessProbe, or startupProbe set
+		if initCtr.Lifecycle != nil || initCtr.LivenessProbe != nil || initCtr.ReadinessProbe != nil || initCtr.StartupProbe != nil {
+			return nil, errors.Errorf("cannot create an init container that has either of lifecycle, livenessProbe, readinessProbe, or startupProbe set")
+		}
+		pulledImage, labels, err := ic.getImageAndLabelInfo(ctx, cwd, annotations, writer, initCtr, options)
+		if err != nil {
+			return nil, err
+		}
+
+		specgenOpts := kube.CtrSpecGenOptions{
+			Container:         initCtr,
+			Image:             pulledImage,
+			Volumes:           volumes,
+			PodID:             pod.ID(),
+			PodName:           podName,
+			PodInfraID:        podInfraID,
+			ConfigMaps:        configMaps,
+			SeccompPaths:      seccompPaths,
+			RestartPolicy:     ctrRestartPolicy,
+			NetNSIsHost:       p.NetNS.IsHost(),
+			SecretsManager:    secretsManager,
+			LogDriver:         options.LogDriver,
+			Labels:            labels,
+			InitContainerType: define.AlwaysInitContainer,
+		}
+		specGen, err := kube.ToSpecGen(ctx, &specgenOpts)
+		if err != nil {
+			return nil, err
+		}
+		rtSpec, spec, opts, err := generate.MakeContainer(ctx, ic.Libpod, specGen)
+		if err != nil {
+			return nil, err
+		}
+		ctr, err := generate.ExecuteCreate(ctx, ic.Libpod, rtSpec, spec, false, opts...)
+		if err != nil {
+			return nil, err
+		}
+
+		initContainers = append(initContainers, ctr)
+	}
 	for _, container := range podYAML.Spec.Containers {
 		if !strings.Contains("infra", container.Name) {
-			// Contains all labels obtained from kube
-			labels := make(map[string]string)
-			var pulledImage *libimage.Image
-			buildFile, err := getBuildFile(container.Image, cwd)
+			pulledImage, labels, err := ic.getImageAndLabelInfo(ctx, cwd, annotations, writer, container, options)
 			if err != nil {
 				return nil, err
 			}
-			existsLocally, err := ic.Libpod.LibimageRuntime().Exists(container.Image)
-			if err != nil {
-				return nil, err
-			}
-			if (len(buildFile) > 0 && !existsLocally) || (len(buildFile) > 0 && options.Build) {
-				buildOpts := new(buildahDefine.BuildOptions)
-				commonOpts := new(buildahDefine.CommonBuildOptions)
-				buildOpts.ConfigureNetwork = buildahDefine.NetworkDefault
-				buildOpts.Isolation = buildahDefine.IsolationChroot
-				buildOpts.CommonBuildOpts = commonOpts
-				buildOpts.Output = container.Image
-				if _, _, err := ic.Libpod.Build(ctx, *buildOpts, []string{buildFile}...); err != nil {
-					return nil, err
-				}
-				i, _, err := ic.Libpod.LibimageRuntime().LookupImage(container.Image, new(libimage.LookupImageOptions))
-				if err != nil {
-					return nil, err
-				}
-				pulledImage = i
-			} else {
-				// NOTE: set the pull policy to "newer".  This will cover cases
-				// where the "latest" tag requires a pull and will also
-				// transparently handle "localhost/" prefixed files which *may*
-				// refer to a locally built image OR an image running a
-				// registry on localhost.
-				pullPolicy := config.PullPolicyNewer
-				if len(container.ImagePullPolicy) > 0 {
-					// Make sure to lower the strings since K8s pull policy
-					// may be capitalized (see bugzilla.redhat.com/show_bug.cgi?id=1985905).
-					rawPolicy := string(container.ImagePullPolicy)
-					pullPolicy, err = config.ParsePullPolicy(strings.ToLower(rawPolicy))
-					if err != nil {
-						return nil, err
-					}
-				}
-				pulledImages, err := pullImage(ic, writer, container.Image, options, pullPolicy)
-				if err != nil {
-					return nil, err
-				}
-				pulledImage = pulledImages[0]
-			}
-
-			// Handle kube annotations
-			for k, v := range annotations {
-				switch k {
-				// Auto update annotation without container name will apply to
-				// all containers within the pod
-				case autoupdate.Label, autoupdate.AuthfileLabel:
-					labels[k] = v
-				// Auto update annotation with container name will apply only
-				// to the specified container
-				case fmt.Sprintf("%s/%s", autoupdate.Label, container.Name),
-					fmt.Sprintf("%s/%s", autoupdate.AuthfileLabel, container.Name):
-					prefixAndCtr := strings.Split(k, "/")
-					labels[prefixAndCtr[0]] = v
-				}
-			}
 
 			specgenOpts := kube.CtrSpecGenOptions{
 				Container:      container,
@@ -394,7 +377,6 @@ func (ic *ContainerEngine) playKubePod(ctx context.Context, podName string, podY
 			if err != nil {
 				return nil, err
 			}
-
 			rtSpec, spec, opts, err := generate.MakeContainer(ctx, ic.Libpod, specGen)
 			if err != nil {
 				return nil, err
@@ -423,12 +405,96 @@ func (ic *ContainerEngine) playKubePod(ctx context.Context, podName string, podY
 	for _, ctr := range containers {
 		playKubePod.Containers = append(playKubePod.Containers, ctr.ID())
 	}
+	for _, initCtr := range initContainers {
+		playKubePod.InitContainers = append(playKubePod.InitContainers, initCtr.ID())
+	}
 
 	report.Pods = append(report.Pods, playKubePod)
 
 	return &report, nil
 }
 
+// getImageAndLabelInfo returns the image information and how the image should be pulled plus as well as labels to be used for the container in the pod.
+// Moved this to a separate function so that it can be used for both init and regular containers when playing a kube yaml.
+func (ic *ContainerEngine) getImageAndLabelInfo(ctx context.Context, cwd string, annotations map[string]string, writer io.Writer, container v1.Container, options entities.PlayKubeOptions) (*libimage.Image, map[string]string, error) {
+	// Contains all labels obtained from kube
+	labels := make(map[string]string)
+	var pulledImage *libimage.Image
+	buildFile, err := getBuildFile(container.Image, cwd)
+	if err != nil {
+		return nil, nil, err
+	}
+	existsLocally, err := ic.Libpod.LibimageRuntime().Exists(container.Image)
+	if err != nil {
+		return nil, nil, err
+	}
+	if (len(buildFile) > 0 && !existsLocally) || (len(buildFile) > 0 && options.Build) {
+		buildOpts := new(buildahDefine.BuildOptions)
+		commonOpts := new(buildahDefine.CommonBuildOptions)
+		buildOpts.ConfigureNetwork = buildahDefine.NetworkDefault
+		buildOpts.Isolation = buildahDefine.IsolationChroot
+		buildOpts.CommonBuildOpts = commonOpts
+		buildOpts.Output = container.Image
+		if _, _, err := ic.Libpod.Build(ctx, *buildOpts, []string{buildFile}...); err != nil {
+			return nil, nil, err
+		}
+		i, _, err := ic.Libpod.LibimageRuntime().LookupImage(container.Image, new(libimage.LookupImageOptions))
+		if err != nil {
+			return nil, nil, err
+		}
+		pulledImage = i
+	} else {
+		// NOTE: set the pull policy to "newer".  This will cover cases
+		// where the "latest" tag requires a pull and will also
+		// transparently handle "localhost/" prefixed files which *may*
+		// refer to a locally built image OR an image running a
+		// registry on localhost.
+		pullPolicy := config.PullPolicyNewer
+		if len(container.ImagePullPolicy) > 0 {
+			// Make sure to lower the strings since K8s pull policy
+			// may be capitalized (see bugzilla.redhat.com/show_bug.cgi?id=1985905).
+			rawPolicy := string(container.ImagePullPolicy)
+			pullPolicy, err = config.ParsePullPolicy(strings.ToLower(rawPolicy))
+			if err != nil {
+				return nil, nil, err
+			}
+		}
+		// This ensures the image is the image store
+		pullOptions := &libimage.PullOptions{}
+		pullOptions.AuthFilePath = options.Authfile
+		pullOptions.CertDirPath = options.CertDir
+		pullOptions.SignaturePolicyPath = options.SignaturePolicy
+		pullOptions.Writer = writer
+		pullOptions.Username = options.Username
+		pullOptions.Password = options.Password
+		pullOptions.InsecureSkipTLSVerify = options.SkipTLSVerify
+
+		pulledImages, err := ic.Libpod.LibimageRuntime().Pull(ctx, container.Image, pullPolicy, pullOptions)
+		if err != nil {
+			return nil, nil, err
+		}
+		pulledImage = pulledImages[0]
+	}
+
+	// Handle kube annotations
+	for k, v := range annotations {
+		switch k {
+		// Auto update annotation without container name will apply to
+		// all containers within the pod
+		case autoupdate.Label, autoupdate.AuthfileLabel:
+			labels[k] = v
+		// Auto update annotation with container name will apply only
+		// to the specified container
+		case fmt.Sprintf("%s/%s", autoupdate.Label, container.Name),
+			fmt.Sprintf("%s/%s", autoupdate.AuthfileLabel, container.Name):
+			prefixAndCtr := strings.Split(k, "/")
+			labels[prefixAndCtr[0]] = v
+		}
+	}
+
+	return pulledImage, labels, nil
+}
+
 // playKubePVC creates a podman volume from a kube persistent volume claim.
 func (ic *ContainerEngine) playKubePVC(ctx context.Context, pvcYAML *v1.PersistentVolumeClaim, options entities.PlayKubeOptions) (*entities.PlayKubeReport, error) {
 	var report entities.PlayKubeReport
diff --git a/pkg/specgen/generate/kube/kube.go b/pkg/specgen/generate/kube/kube.go
index 5188abc3a..c01d7a1f0 100644
--- a/pkg/specgen/generate/kube/kube.go
+++ b/pkg/specgen/generate/kube/kube.go
@@ -114,6 +114,9 @@ type CtrSpecGenOptions struct {
 	Labels map[string]string
 	//
 	IsInfra bool
+	// InitContainerType sets what type the init container is
+	// Note: When playing a kube yaml, the inti container type will be set to "always" only
+	InitContainerType string
 }
 
 func ToSpecGen(ctx context.Context, opts *CtrSpecGenOptions) (*specgen.SpecGenerator, error) {
@@ -135,6 +138,8 @@ func ToSpecGen(ctx context.Context, opts *CtrSpecGenOptions) (*specgen.SpecGener
 		Driver: opts.LogDriver,
 	}
 
+	s.InitContainerType = opts.InitContainerType
+
 	setupSecurityContext(s, opts.Container)
 	err := setupLivenessProbe(s, opts.Container, opts.RestartPolicy)
 	if err != nil {
diff --git a/test/e2e/generate_kube_test.go b/test/e2e/generate_kube_test.go
index 8996bf6a0..bf89a0708 100644
--- a/test/e2e/generate_kube_test.go
+++ b/test/e2e/generate_kube_test.go
@@ -174,6 +174,78 @@ var _ = Describe("Podman generate kube", func() {
 		Expect(string(kube.Out.Contents())).To(ContainSubstring(`name: pod2`))
 	})
 
+	It("podman generate kube on pod with init containers", func() {
+		session := podmanTest.Podman([]string{"create", "--pod", "new:toppod", "--init-ctr", "always", ALPINE, "echo", "hello"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		session = podmanTest.Podman([]string{"create", "--pod", "toppod", "--init-ctr", "always", ALPINE, "echo", "world"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		session = podmanTest.Podman([]string{"create", "--pod", "toppod", ALPINE, "top"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		kube := podmanTest.Podman([]string{"generate", "kube", "toppod"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube).Should(Exit(0))
+
+		pod := new(v1.Pod)
+		err := yaml.Unmarshal(kube.Out.Contents(), pod)
+		Expect(err).To(BeNil())
+		Expect(pod.Spec.HostNetwork).To(Equal(false))
+
+		numContainers := len(pod.Spec.Containers) + len(pod.Spec.InitContainers)
+		Expect(numContainers).To(Equal(3))
+
+		// Init container should be in the generated kube yaml if created with "once" type and the pod has not been started
+		session = podmanTest.Podman([]string{"create", "--pod", "new:toppod-2", "--init-ctr", "once", ALPINE, "echo", "using once type"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		session = podmanTest.Podman([]string{"create", "--pod", "toppod-2", ALPINE, "top"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		kube = podmanTest.Podman([]string{"generate", "kube", "toppod-2"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube).Should(Exit(0))
+
+		pod = new(v1.Pod)
+		err = yaml.Unmarshal(kube.Out.Contents(), pod)
+		Expect(err).To(BeNil())
+		Expect(pod.Spec.HostNetwork).To(Equal(false))
+
+		numContainers = len(pod.Spec.Containers) + len(pod.Spec.InitContainers)
+		Expect(numContainers).To(Equal(2))
+
+		// Init container should not be in the generated kube yaml if created with "once" type and the pod has been started
+		session = podmanTest.Podman([]string{"create", "--pod", "new:toppod-3", "--init-ctr", "once", ALPINE, "echo", "using once type"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		session = podmanTest.Podman([]string{"create", "--pod", "toppod-3", ALPINE, "top"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		session = podmanTest.Podman([]string{"pod", "start", "toppod-3"})
+		session.WaitWithDefaultTimeout()
+		Expect(session).Should(Exit(0))
+
+		kube = podmanTest.Podman([]string{"generate", "kube", "toppod-3"})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube).Should(Exit(0))
+
+		pod = new(v1.Pod)
+		err = yaml.Unmarshal(kube.Out.Contents(), pod)
+		Expect(err).To(BeNil())
+		Expect(pod.Spec.HostNetwork).To(Equal(false))
+
+		numContainers = len(pod.Spec.Containers) + len(pod.Spec.InitContainers)
+		Expect(numContainers).To(Equal(1))
+	})
+
 	It("podman generate kube on pod with host network", func() {
 		podSession := podmanTest.Podman([]string{"pod", "create", "--name", "testHostNetwork", "--network", "host"})
 		podSession.WaitWithDefaultTimeout()
diff --git a/test/e2e/play_kube_test.go b/test/e2e/play_kube_test.go
index fa30f068c..15bd10616 100644
--- a/test/e2e/play_kube_test.go
+++ b/test/e2e/play_kube_test.go
@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/containers/common/pkg/config"
+	"github.com/containers/podman/v3/libpod/define"
 	"github.com/containers/podman/v3/pkg/util"
 	. "github.com/containers/podman/v3/test/utils"
 	"github.com/containers/storage/pkg/stringid"
@@ -263,6 +264,17 @@ spec:
   {{ end }}
     ip: {{ .IP }}
 {{ end }}
+  initContainers:
+{{ with .InitCtrs }}
+  {{ range . }}
+  - command:
+    {{ range .Cmd }}
+    - {{.}}
+    {{ end }}
+    image: {{ .Image }}
+    name: {{ .Name }}
+  {{ end }}
+{{ end }}
   containers:
 {{ with .Ctrs }}
   {{ range . }}
@@ -665,6 +677,7 @@ type Pod struct {
 	HostNetwork   bool
 	HostAliases   []HostAlias
 	Ctrs          []*Ctr
+	InitCtrs      []*Ctr
 	Volumes       []*Volume
 	Labels        map[string]string
 	Annotations   map[string]string
@@ -686,6 +699,7 @@ func getPod(options ...podOption) *Pod {
 		HostNetwork:   false,
 		HostAliases:   nil,
 		Ctrs:          make([]*Ctr, 0),
+		InitCtrs:      make([]*Ctr, 0),
 		Volumes:       make([]*Volume, 0),
 		Labels:        make(map[string]string),
 		Annotations:   make(map[string]string),
@@ -728,6 +742,12 @@ func withCtr(c *Ctr) podOption {
 	}
 }
 
+func withPodInitCtr(ic *Ctr) podOption {
+	return func(pod *Pod) {
+		pod.InitCtrs = append(pod.InitCtrs, ic)
+	}
+}
+
 func withRestartPolicy(policy string) podOption {
 	return func(pod *Pod) {
 		pod.RestartPolicy = policy
@@ -847,6 +867,7 @@ type Ctr struct {
 	VolumeReadOnly  bool
 	Env             []Env
 	EnvFrom         []EnvFrom
+	InitCtrType     string
 }
 
 // getCtr takes a list of ctrOptions and returns a Ctr with sane defaults
@@ -870,6 +891,7 @@ func getCtr(options ...ctrOption) *Ctr {
 		VolumeReadOnly:  false,
 		Env:             []Env{},
 		EnvFrom:         []EnvFrom{},
+		InitCtrType:     "",
 	}
 	for _, option := range options {
 		option(&c)
@@ -885,6 +907,12 @@ func withName(name string) ctrOption {
 	}
 }
 
+func withInitCtr() ctrOption {
+	return func(c *Ctr) {
+		c.InitCtrType = define.AlwaysInitContainer
+	}
+}
+
 func withCmd(cmd []string) ctrOption {
 	return func(c *Ctr) {
 		c.Cmd = cmd
@@ -1294,6 +1322,33 @@ var _ = Describe("Podman play kube", func() {
 		Expect(inspect.OutputToString()).To(ContainSubstring(`[]`))
 	})
 
+	// If you have an init container in the pod yaml, podman should create and run the init container with play kube
+	It("podman play kube test with init containers", func() {
+		pod := getPod(withPodInitCtr(getCtr(withImage(ALPINE), withCmd([]string{"echo", "hello"}), withInitCtr(), withName("init-test"))), withCtr(getCtr(withImage(ALPINE), withCmd([]string{"top"}))))
+		err := generateKubeYaml("pod", pod, kubeYaml)
+		Expect(err).To(BeNil())
+
+		kube := podmanTest.Podman([]string{"play", "kube", kubeYaml})
+		kube.WaitWithDefaultTimeout()
+		Expect(kube).Should(Exit(0))
+
+		// Expect the number of containers created to be 3, one init, infra, and regular container
+		numOfCtrs := podmanTest.NumberOfContainers()
+		Expect(numOfCtrs).To(Equal(3))
+
+		// Init container should have exited after running
+		inspect := podmanTest.Podman([]string{"inspect", "--format", "{{.State.Status}}", "testPod-init-test"})
+		inspect.WaitWithDefaultTimeout()
+		Expect(inspect).Should(Exit(0))
+		Expect(inspect.OutputToString()).To(ContainSubstring("exited"))
+
+		// Regular container should be in running state
+		inspect = podmanTest.Podman([]string{"inspect", "--format", "{{.State.Status}}", "testPod-" + defaultCtrName})
+		inspect.WaitWithDefaultTimeout()
+		Expect(inspect).Should(Exit(0))
+		Expect(inspect.OutputToString()).To(ContainSubstring("running"))
+	})
+
 	// If you supply only args for a Container, the default Entrypoint defined in the Docker image is run with the args that you supplied.
 	It("podman play kube test correct command with only set args in yaml file", func() {
 		pod := getPod(withCtr(getCtr(withImage(registry), withCmd(nil), withArg([]string{"echo", "hello"}))))