Method spawn_builder

lib-engine/src/cmd/docker.rs:346–481

Spawns a new Docker buildx builder on Kubernetes. Each architecture gets a buildx node whose name is: `{builder_prefix}{exec_id}-{arch}` (truncated to 60 chars) Kubernetes then creates a pod named `{node_name}-{random_suffix}`. For example, with `exec_id = "03d…ef-3999-0"` and `builder_prefix = "build-"`: node = `build-03d49150-a2f5-4fb5-ba90-2c94e32dd9ef-3999-0-amd64` pod = `build-03d49150-

(
        &self,
        exec_id: &str,
        builder_name: &str,
        nb_builder: NonZeroUsize,
        requested_architectures: &[Architecture],
        (cpu_request_milli, cpu_limit_milli): (u

    /// The deterministic node name (without the random suffix) can be used to
    /// identify build pods in monitoring dashboards (e.g., Grafana).
    pub fn spawn_builder(
        &self,
        exec_id: &str,
        builder_name: &str,
        nb_builder: NonZeroUsize,
        requested_architectures: &[Architecture],
        (cpu_request_milli, cpu_limit_milli): (u32, u32),
        (memory_request_gib, memory_limit_gib): (u32, u32),
        ephemeral_storage_gib: Option<u32>,
        should_abort: &CommandKiller,
        http_registries: &[&str],
        tls_invalid_registries: &[&str],
        bootstrap_builder: bool,
    ) -> Result<BuilderHandle, DockerError> {
        match &self.builder_location {
            // For local builder, we have at max 1 builder available
            BuilderLocation::Local => Ok(BuilderHandle {
                config_path: self.config_path.path().to_path_buf(),
                nb_builder: NonZeroUsize::new(1).unwrap(),
                builder_name: None,
            }),
            BuilderLocation::Kubernetes {
                namespace,
                builder_prefix,
                supported_architectures,
                enable_rootless,
            } => {
                let available_architectures = requested_architectures
                    .iter()
                    .filter(|arch| supported_architectures.contains(arch))
                    .count();

                if available_architectures != requested_architectures.len() {
                    return Err(DockerError::InvalidConfig {
                        raw_error_message: format!(
                            "Some requested architectures are not supported by current docker builder. Available architectures are {supported_architectures:?} while requested are {requested_architectures:?}."
                        ),
                    });
                }

                // We create build handle here to force the drop to run if some operation fail
                let builder_name = format!("qovery-{builder_name}");
                let build_handle = BuilderHandle {
                    config_path: self.config_path.path().to_path_buf(),
                    nb_builder,
                    builder_name: Some(builder_name.clone()),
                };

                info!("docker spawn builder {:?} {:?}", builder_name, requested_architectures);
                let buildkitd_cfg_arg = {
                    let cfg_path = self.config_path.path().join("buildkitd.toml");
                    let mut cfg_file = String::new();
                    for http in http_registries {
                        cfg_file.push_str(&format!("[registry.\"{http}\"]\n  http = true\n"));
                    }
                    for tls in tls_invalid_registries {
                        cfg_file.push_str(&format!("[registry.\"{tls}\"]\n  insecure = true\n"));
                    }