Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
podman-kube-generate(1)      General Commands Manual	 podman-kube-generate(1)

NAME
     podman-kube-generate  -  Generate Kubernetes YAML based on containers, pods
     or volumes

SYNOPSIS
     podman kube generate [options] container... | pod... | volume...

DESCRIPTION
     podman kube generate generates Kubernetes YAML (v1 specification) from Pod-
     man containers, pods or volumes. Regardless of whether  the  input  is  for
     containers or pods, Podman generates the specification as a Pod by default.
     The  input  may  be  in the form of one or more containers, pods or volumes
     names or IDs.

     Podman Containers or Pods

     Volumes appear in the generated YAML  according  to  two  different  volume
     types.  Bind-mounted volumes become hostPath volume types and named volumes
     become persistentVolumeClaim volume types. Generated hostPath volume  types
     are one of three subtypes depending on the state of the host path: Directo-
     ryOrCreate  when  no  file  or directory exists at the host, Directory when
     host path is a directory, or File when host path is a file. The  value  for
     claimName	for a persistentVolumeClaim is the name of the named volume reg-
     istered in Podman.

     Potential name conflicts between volumes are avoided by  using  a	standard
     naming scheme for each volume type. The hostPath volume types are named ac-
     cording to the path on the host machine, replacing forward slashes with hy-
     phens  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  asso-
     ciated named volume suffixed with -pvc.

     Note  that  if  an init container is created with type once and the pod has
     been started, it does 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 is in the generated kube YAML.  Init containers
     created with type always are always generated in the kube YAML as they  are
     never deleted, even after running to completion.

     Note:  When  using volumes and generating a Kubernetes YAML for an unprivi-
     leged and rootless podman container on an SELinux enabled system,	 one  of
     the following options must be completed:
       * Add the "privileged: true" option to the pod spec
       *  Add  type:  spc_t  under the securityContext seLinuxOptions in the pod
     spec
       * Relabel the volume via the CLI command  chcon	-t  container_file_t  -R
     <directory>

     Once  completed,  the correct permissions are in place to access the volume
     when the pod/container is created in a Kubernetes cluster.

     Note that the generated Kubernetes YAML file can be used to re-run the  de-
     ployment via podman-play-kube(1).

     Note that if the pod being generated was created with the --infra-name flag
     set,  then  the generated kube yaml will have the io.podman.annotations.in-
     fra.name set where the value is the name of the infra container set by  the
     user.

     Note  that both Deployment and DaemonSet can only have restartPolicy set to
     Always.

     Note that Job can only have restartPolicy set to OnFailure or Never. By de-
     fault, podman sets it to Never when generating a kube yaml using kube  gen-
     erate.

OPTIONS
   --filename, -f=filename
     Output  to  the  given  file instead of STDOUT. If the file already exists,
     kube generate refuses to replace it and returns an error.

   --podman-only
     Add podman-only reserved annotations in generated YAML file (Cannot be used
     by Kubernetes)

   --replicas, -r=replica count
     The value to set replicas to when generating a Deployment kind.  Note: this
     can only be set with the option --type=deployment.

   --service, -s
     Generate a Kubernetes service object in addition to the Pods. Used to  gen-
     erate a Service specification for the corresponding Pod output. In particu-
     lar, if the object has portmap bindings, the service specification includes
     a	NodePort declaration to expose the service. A random port is assigned by
     Podman in the specification.

   --type, -t=pod | deployment | daemonset | job
     The Kubernetes kind to generate in the YAML file. Currently, the only  sup-
     ported  Kubernetes  specifications are Pod, Deployment, Job, and DaemonSet.
     By default, the Pod specification is generated.

EXAMPLES
     Create Kubernetes Pod YAML for the specified container.

     $ podman kube generate some-mariadb
     # Save the output of this file and use kubectl create -f to import
     # it into Kubernetes.
     #
     # Created with podman-4.8.2

     # NOTE: If you generated this yaml from an unprivileged and rootless podman container on an SELinux
     # enabled system, check the podman generate kube man page for steps to follow to ensure that your pod/container
     # has the right permissions to access the volumes added.
     ---
     apiVersion: v1
     kind: Pod
     metadata:
       creationTimestamp: "2024-01-09T02:24:55Z"
       labels:
	 app: some-mariadb-pod
       name: some-mariadb-pod
     spec:
       containers:
       - args:
	 - mariadbd
	 env:
	 - name: MARIADB_ROOT_PASSWORD
	   value: x
	 image: docker.io/library/mariadb:10.11
	 name: some-mariadb
	 ports:
	 - containerPort: 3306
	   hostPort: 34891
	 volumeMounts:
	 - mountPath: /var/lib/mysql
	   name: mariadb_data-pvc
       volumes:
       - name: mariadb_data-pvc
	 persistentVolumeClaim:
	   claimName: mariadb_data

     Create Kubernetes Deployment YAML with 3 replicas for  the  specified  con-
     tainer.

     $ podman kube generate --type deployment --replicas 3 dep-ct
     r
     # Save the output of this file and use kubectl create -f to import
     # it into Kubernetes.
     #
     # Created with podman-4.5.0-dev
     apiVersion: apps/v1
     kind: Deployment
     metadata:
       creationTimestamp: "2023-03-27T20:45:08Z"
       labels:
	 app: dep-ctr-pod
       name: dep-ctr-pod-deployment
     spec:
       replicas: 3
       selector:
	 matchLabels:
	   app: dep-ctr-pod
       template:
	 metadata:
	   annotations:
	     io.podman.annotations.ulimit: nofile=524288:524288,nproc=127332:127332
	   creationTimestamp: "2023-03-27T20:45:08Z"
	   labels:
	     app: dep-ctr-pod
	   name: dep-ctr-pod
	 spec:
	   containers:
	   - command:
	     - top
	     image: docker.io/library/alpine:latest
	     name: dep-ctr

     Create Kubernetes Pod YAML for the specified container with the host direc-
     tory /home/user/my-data bind-mounted onto the container path /volume.

     $ podman kube generate my-container-with-bind-mounted-data
     # Save the output of this file and use kubectl create -f to import
     # it into Kubernetes.
     #
     # Created with podman-3.1.0-dev
     apiVersion: v1
     kind: Pod
     metadata:
       creationTimestamp: "2021-03-18T16:26:08Z"
       labels:
	 app: my-container-with-bind-mounted-data
       name: my-container-with-bind-mounted-data
     spec:
       containers:
       - command:
	 - /bin/sh
	 image: docker.io/library/alpine:latest
	 name: test-bind-mount
	 volumeMounts:
	 - mountPath: /volume
	   name: home-user-my-data-host
       restartPolicy: Never
       volumes:
       - hostPath:
	   path: /home/user/my-data
	   type: Directory
	 name: home-user-my-data-host

     Create  Kubernetes  Pod  YAML for the specified container with named volume
     priceless-data mounted onto the container path /volume.

     $ podman kube generate my-container-using-priceless-data
     # Save the output of this file and use kubectl create -f to import
     # it into Kubernetes.
     #
     # Created with podman-3.1.0-dev
     apiVersion: v1
     kind: Pod
     metadata:
       creationTimestamp: "2021-03-18T16:26:08Z"
       labels:
	 app: my-container-using-priceless-data
       name: my-container-using-priceless-data
     spec:
       containers:
       - command:
	 - /bin/sh
	 image: docker.io/library/alpine:latest
	 name: test-bind-mount
	 volumeMounts:
	 - mountPath: /volume
	   name: priceless-data-pvc
       restartPolicy: Never
       volumes:
       - name: priceless-data-pvc
	 persistentVolumeClaim:
	   claimName: priceless-data

     Create Kubernetes Pod YAML for the specified pod and include a service.

     $ sudo podman kube generate -s demoweb
     # Save the output of this file and use kubectl create -f to import
     # it into Kubernetes.
     #
     # Created with podman-0.12.2-dev
     apiVersion: v1
     kind: Pod
     metadata:
       creationTimestamp: 2018-12-18T15:16:06Z
       labels:
	 app: demoweb
       name: demoweb-libpod
     spec:
       containers:
       - command:
	 - python3
	 - /root/code/graph.py
	 image: quay.io/baude/demoweb:latest
	 name: practicalarchimedes
	 tty: true
	 workingDir: /root/code
     ---
     apiVersion: v1
     kind: Service
     metadata:
       creationTimestamp: 2018-12-18T15:16:06Z
       labels:
	 app: demoweb
       name: demoweb-libpod
     spec:
       ports:
       - name: "8050"
	 nodePort: 31269
	 port: 8050
	 targetPort: 0
       selector:
	 app: demoweb
       type: NodePort
     status:
       loadBalancer: {}

SEE ALSO
     podman(1), podman-container(1), podman-pod(1), podman-kube-play(1), podman-
     kube-down(1)

HISTORY
     December 2018, Originally compiled by Brent Baude	(bbaude  at  redhat  dot
     com)

							 podman-kube-generate(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=podman-generate-kube&sektion=1&manpath=FreeBSD+Ports+15.1.quarterly>

home | help