Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package podman
import (
"bufio"
"cmp"
"errors"
"fmt"
"maps"
"net/http"
"os"
"slices"
"strconv"
"strings"
"github.com/docker/go-connections/nat"
"github.com/getarcaneapp/arcane/types/v2/podman"
"github.com/spf13/cobra"
"go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
"github.com/getarcaneapp/arcane/cli/v2/internal/output"
"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)
var podNetworkModes = []string{"bridge", "host", "none", "private", "slirp4netns", "pasta", "ns"}
type podCreateOptions struct {
name string
hostname string
labels map[string]string
labelFiles []string
exitPolicy string
restart string
infra bool
infraImage string
infraCommand string
infraName string
infraConmonPidFile string
share string
shareParent bool
pid string
ipc string
uts string
userns string
uidMap []string
gidMap []string
networks []string
networkAliases []string
ip string
ip6 string
macAddress string
publish []string
dns []string
dnsSearch []string
dnsOptions []string
addHosts []string
noHosts bool
noHostname bool
hostsFile string
cgroupParent string
cpus float64
cpuShares uint64
cpusetCPUs string
cpusetMems string
memory string
memorySwap string
blkioWeight uint16
blkioWeightDevices []string
deviceReadBps []string
deviceWriteBps []string
devices []string
gpus []string
volumes []string
volumesFrom []string
shmSize string
shmSizeSystemd string
securityOpt []string
sysctl map[string]string
}
func newPodCreateCmd() *cobra.Command {
var opts podCreateOptions
cmd := &cobra.Command{
Use: "create",
Short: "Create a pod",
SilenceUsage: true,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error {
req, err := opts.request(cmd)
if err != nil {
return err
}
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[podman.PodCreateResponse]{
Method: http.MethodPost,
Path: types.PodmanPods(c.EnvID()),
Body: req,
FailureMessage: "failed to create pod",
Render: func(data podman.PodCreateResponse) error {
output.Success("Pod %s created successfully", opts.name)
output.KeyValue("ID", data.ID)
return nil
},
})
},
}
flags := cmd.Flags()
flags.StringVarP(&opts.name, "name", "n", "", "Pod name (required)")
flags.StringVar(&opts.hostname, "hostname", "", "Pod hostname")
flags.StringToStringVarP(&opts.labels, "label", "l", nil, "Label (KEY=VALUE)")
flags.StringArrayVar(&opts.labelFiles, "label-file", nil, "Read labels from a local file of KEY=VALUE lines")
flags.StringVar(&opts.exitPolicy, "exit-policy", "", "Behaviour when the last container exits (continue or stop)")
flags.StringVar(&opts.restart, "restart", "", "Restart policy for containers (no, always, on-failure[:N], unless-stopped)")
flags.BoolVar(&opts.infra, "infra", true, "Create an infra container to share namespaces with")
flags.StringVar(&opts.infraImage, "infra-image", "", "Image for the infra container")
flags.StringVar(&opts.infraCommand, "infra-command", "", "Entrypoint of the infra container")
flags.StringVar(&opts.infraName, "infra-name", "", "Name of the infra container")
flags.StringVar(&opts.infraConmonPidFile, "infra-conmon-pidfile", "", "Path that receives the infra container's conmon PID")
flags.StringVar(&opts.share, "share", "", "Comma-separated namespaces to share (default ipc,net,uts; prefix + to add to the default)")
flags.BoolVar(&opts.shareParent, "share-parent", true, "Use the pod's cgroup as the cgroup parent of its containers")
flags.StringVar(&opts.pid, "pid", "", "PID namespace (host, private, ns:PATH, container:ID)")
flags.StringVar(&opts.ipc, "ipc", "", "IPC namespace (host, private, shareable, none, ns:PATH, container:ID)")
flags.StringVar(&opts.uts, "uts", "", "UTS namespace (host, private, ns:PATH, container:ID)")
flags.StringVar(&opts.userns, "userns", "", "User namespace (auto, keep-id[:OPTS], host, nomap, ns:PATH)")
flags.StringSliceVar(&opts.uidMap, "uidmap", nil, "UID mapping CONTAINER:HOST:SIZE")
flags.StringSliceVar(&opts.gidMap, "gidmap", nil, "GID mapping CONTAINER:HOST:SIZE")
flags.StringArrayVar(&opts.networks, "network", nil, "Network mode (bridge, host, none, private, slirp4netns[:OPTS], pasta[:OPTS], ns:PATH) or network NAME[:alias=A,ip=IP,mac=MAC,interface_name=IF]")
flags.StringSliceVar(&opts.networkAliases, "network-alias", nil, "Network-scoped alias on the --network")
flags.StringVar(&opts.ip, "ip", "", "Static IPv4 address on the --network")
flags.StringVar(&opts.ip6, "ip6", "", "Static IPv6 address on the --network")
flags.StringVar(&opts.macAddress, "mac-address", "", "Static MAC address on the --network")
flags.StringArrayVarP(&opts.publish, "publish", "p", nil, "Publish a port ([hostIp:][hostPort:]containerPort[/protocol])")
flags.StringSliceVar(&opts.dns, "dns", nil, "DNS server, or none to keep the image's resolv.conf")
flags.StringSliceVar(&opts.dnsSearch, "dns-search", nil, "DNS search domain")
flags.StringSliceVar(&opts.dnsOptions, "dns-option", nil, "DNS resolver option")
flags.StringSliceVar(&opts.addHosts, "add-host", nil, "Extra /etc/hosts entry (HOST:IP)")
flags.BoolVar(&opts.noHosts, "no-hosts", false, "Use the image's /etc/hosts")
flags.BoolVar(&opts.noHostname, "no-hostname", false, "Use the image's /etc/hostname")
flags.StringVar(&opts.hostsFile, "hosts-file", "", "Base file for /etc/hosts, or image or none")
flags.StringVar(&opts.cgroupParent, "cgroup-parent", "", "Parent cgroup of the pod")
flags.Float64Var(&opts.cpus, "cpus", 0, "Number of CPUs")
flags.Uint64VarP(&opts.cpuShares, "cpu-shares", "c", 0, "CPU shares (relative weight)")
flags.StringVar(&opts.cpusetCPUs, "cpuset-cpus", "", "CPUs allowed to run the pod (0-3, 0,1)")
flags.StringVar(&opts.cpusetMems, "cpuset-mems", "", "Memory nodes allowed to run the pod (0-3, 0,1)")
flags.StringVarP(&opts.memory, "memory", "m", "", "Memory limit (512m, 2g)")
flags.StringVar(&opts.memorySwap, "memory-swap", "", "Memory plus swap limit, or -1 for unlimited swap")
flags.Uint16Var(&opts.blkioWeight, "blkio-weight", 0, "Block IO weight (10-1000)")
flags.StringArrayVar(&opts.blkioWeightDevices, "blkio-weight-device", nil, "Per-device block IO weight (MAJOR:MINOR:WEIGHT)")
flags.StringArrayVar(&opts.deviceReadBps, "device-read-bps", nil, "Per-device read rate limit (MAJOR:MINOR:RATE, e.g. 8:0:1mb)")
flags.StringArrayVar(&opts.deviceWriteBps, "device-write-bps", nil, "Per-device write rate limit (MAJOR:MINOR:RATE, e.g. 8:0:1mb)")
flags.StringArrayVar(&opts.devices, "device", nil, "Host device (HOST[:CONTAINER[:PERMISSIONS]])")
flags.StringSliceVar(&opts.gpus, "gpus", nil, "NVIDIA GPUs to add through CDI, or all")
flags.StringArrayVarP(&opts.volumes, "volume", "v", nil, "Bind mount or named volume (SOURCE:DESTINATION[:OPTIONS])")
flags.StringArrayVar(&opts.volumesFrom, "volumes-from", nil, "Mount volumes from a container (CONTAINER[:OPTIONS])")
flags.StringVar(&opts.shmSize, "shm-size", "", "Size of /dev/shm (64m)")
flags.StringVar(&opts.shmSizeSystemd, "shm-size-systemd", "", "Size of systemd tmpfs mounts (64m)")
flags.StringArrayVar(&opts.securityOpt, "security-opt", nil, "Security option (label=disable, seccomp=unconfined)")
flags.StringToStringVar(&opts.sysctl, "sysctl", nil, "Namespaced kernel parameter (KEY=VALUE)")
_ = cmd.MarkFlagRequired("name")
cmdutil.SetScope(cmdutil.ScopeDestination, cmd)
return cmd
}
func (o podCreateOptions) request(cmd *cobra.Command) (podman.PodCreateRequest, error) {
labels, err := o.allLabels()
if err != nil {
return podman.PodCreateRequest{}, err
}
ports := make([]podman.PodPortMapping, 0, len(o.publish))
for _, spec := range o.publish {
mappings, parseErr := nat.ParsePortSpec(spec)
if parseErr != nil {
return podman.PodCreateRequest{}, fmt.Errorf("invalid --publish %q: %w", spec, parseErr)
}
for _, mapping := range mappings {
hostPort, portErr := strconv.ParseUint(cmp.Or(mapping.Binding.HostPort, "0"), 10, 16)
if portErr != nil {
return podman.PodCreateRequest{}, fmt.Errorf("invalid --publish %q: %w", spec, portErr)
}
ports = append(ports, podman.PodPortMapping{
ContainerPort: uint16(mapping.Port.Int()),
HostPort: uint16(hostPort),
HostIP: mapping.Binding.HostIP,
Protocol: mapping.Port.Proto(),
})
}
}
networkMode, networkOptions, networks, err := o.networkSettings()
if err != nil {
return podman.PodCreateRequest{}, err
}
deviceLimits := func(flag string, values []string) ([]podman.PodDeviceLimit, error) {
out := make([]podman.PodDeviceLimit, 0, len(values))
for _, value := range values {
index := strings.LastIndex(value, ":")
if index <= 0 {
return nil, fmt.Errorf("invalid --%s %q: use MAJOR:MINOR:VALUE", flag, value)
}
out = append(out, podman.PodDeviceLimit{Device: value[:index], Value: value[index+1:]})
}
return out, nil
}
weightDevices, err := deviceLimits("blkio-weight-device", o.blkioWeightDevices)
if err != nil {
return podman.PodCreateRequest{}, err
}
readBps, err := deviceLimits("device-read-bps", o.deviceReadBps)
if err != nil {
return podman.PodCreateRequest{}, err
}
writeBps, err := deviceLimits("device-write-bps", o.deviceWriteBps)
if err != nil {
return podman.PodCreateRequest{}, err
}
volumes := make([]podman.PodVolume, 0, len(o.volumes))
for _, value := range o.volumes {
parts := strings.SplitN(value, ":", 3)
if len(parts) < 2 {
return podman.PodCreateRequest{}, fmt.Errorf("invalid --volume %q: use SOURCE:DESTINATION[:OPTIONS]", value)
}
volumes = append(volumes, podman.PodVolume{
Source: parts[0],
Destination: parts[1],
Options: kit.Ternary(len(parts) == 3, strings.Split(parts[len(parts)-1], ","), nil),
})
}
policy, retries, hasRetries := strings.Cut(o.restart, ":")
restartRetries, err := strconv.ParseUint(cmp.Or(retries, "0"), 10, 32)
if err != nil {
return podman.PodCreateRequest{}, fmt.Errorf("invalid --restart %q: %w", o.restart, err)
}
share := strings.TrimSpace(o.share)
noShare := cmd.Flags().Changed("share") && (share == "" || share == "none")
return podman.PodCreateRequest{
Name: o.name,
Hostname: o.hostname,
Labels: kit.Ternary(len(labels) > 0, labels, nil),
ExitPolicy: o.exitPolicy,
RestartPolicy: kit.Ternary(policy == "never", "no", policy),
RestartRetries: kit.Ternary(hasRetries, new(uint(restartRetries)), nil),
NoInfra: !o.infra || (noShare && !cmd.Flags().Changed("infra")),
InfraImage: o.infraImage,
InfraCommand: strings.Fields(o.infraCommand),
InfraName: o.infraName,
InfraConmonPidFile: o.infraConmonPidFile,
SharedNamespaces: func() []string {
if share == "" || noShare {
return nil
}
if added, ok := strings.CutPrefix(share, "+"); ok {
return append([]string{"ipc", "net", "uts"}, strings.Split(added, ",")...)
}
return strings.Split(share, ",")
}(),
ShareParent: kit.Ternary(cmd.Flags().Changed("share-parent"), new(o.shareParent), nil),
Pid: o.pid,
Ipc: o.ipc,
Uts: o.uts,
Userns: o.userns,
UIDMap: o.uidMap,
GIDMap: o.gidMap,
NetworkMode: networkMode,
NetworkOptions: networkOptions,
Networks: networks,
PortMappings: ports,
DNSServers: slices.DeleteFunc(slices.Clone(o.dns), func(server string) bool {
return server == "none"
}),
DNSSearch: o.dnsSearch,
DNSOptions: o.dnsOptions,
NoManageResolvConf: slices.Contains(o.dns, "none"),
AddHosts: o.addHosts,
NoHosts: o.noHosts,
NoHostname: o.noHostname,
HostsFile: o.hostsFile,
CgroupParent: o.cgroupParent,
CPUs: o.cpus,
CPUShares: o.cpuShares,
CPUSetCPUs: o.cpusetCPUs,
CPUSetMems: o.cpusetMems,
Memory: o.memory,
MemorySwap: o.memorySwap,
BlkioWeight: o.blkioWeight,
BlkioWeightDevices: weightDevices,
DeviceReadBps: readBps,
DeviceWriteBps: writeBps,
Devices: o.devices,
GPUs: o.gpus,
Volumes: volumes,
VolumesFrom: o.volumesFrom,
ShmSize: o.shmSize,
ShmSizeSystemd: o.shmSizeSystemd,
SecurityOpt: o.securityOpt,
Sysctl: o.sysctl,
}, nil
}
func (o podCreateOptions) allLabels() (map[string]string, error) {
labels := map[string]string{}
for _, path := range o.labelFiles {
file, err := os.Open(path)
if err != nil {
return nil, fmt.Errorf("read --label-file: %w", err)
}
scanner := bufio.NewScanner(file)
for scanner.Scan() {
line := strings.TrimSpace(scanner.Text())
if line == "" || strings.HasPrefix(line, "#") {
continue
}
key, value, _ := strings.Cut(line, "=")
labels[key] = value
}
if readErr := cmp.Or(scanner.Err(), file.Close()); readErr != nil {
return nil, fmt.Errorf("read --label-file %s: %w", path, readErr)
}
}
maps.Copy(labels, o.labels)
return labels, nil
}
func (o podCreateOptions) networkSettings() (string, []string, []podman.PodNetwork, error) {
var mode string
var options []string
var networks []podman.PodNetwork
for _, value := range o.networks {
name, rest, _ := strings.Cut(value, ":")
if slices.Contains(podNetworkModes, name) {
mode = kit.Ternary(name == "ns", value, name)
options = kit.Ternary(name == "ns" || rest == "", options, strings.Split(rest, ","))
continue
}
network := podman.PodNetwork{Name: name}
for option := range strings.SplitSeq(rest, ",") {
key, optionValue, _ := strings.Cut(option, "=")
switch key {
case "":
case "alias":
network.Aliases = append(network.Aliases, optionValue)
case "ip", "ip6":
network.StaticIPs = append(network.StaticIPs, optionValue)
case "mac":
network.StaticMAC = optionValue
case "interface_name":
network.InterfaceName = optionValue
default:
return "", nil, nil, fmt.Errorf("invalid --network option %q", option)
}
}
networks = append(networks, network)
}
if len(o.networkAliases) == 0 && o.ip == "" && o.ip6 == "" && o.macAddress == "" {
return mode, options, networks, nil
}
if len(networks) != 1 {
return "", nil, nil, errors.New("--ip, --ip6, --mac-address, and --network-alias need exactly one --network NAME")
}
networks[0] = podman.PodNetwork{
Name: networks[0].Name,
Aliases: append(networks[0].Aliases, o.networkAliases...),
StaticIPs: slices.DeleteFunc(append(networks[0].StaticIPs, o.ip, o.ip6), func(ip string) bool {
return ip == ""
}),
StaticMAC: cmp.Or(o.macAddress, networks[0].StaticMAC),
InterfaceName: networks[0].InterfaceName,
}
return mode, options, networks, nil
}