feat: support pack_git_packages and fix add group for alpine (#5295)

* feat: pack git packages

Signed-off-by: Frost Ming <me@frostming.com>

* fix: add group command for alpine

Signed-off-by: Frost Ming <me@frostming.com>

---------

Signed-off-by: Frost Ming <me@frostming.com>

Author: frostming

src/_bentoml_sdk/images.py

@@ -9,6 +9,7 @@
 from pathlib import Path
 
 import attrs
+import fs
 
 from bentoml._internal.bento.bento import ImageInfo
 from bentoml._internal.bento.build_config import BentoBuildConfig
@@ -18,10 +19,14 @@
 from bentoml._internal.configuration import get_quiet_mode
 from bentoml._internal.container.frontend.dockerfile import CONTAINER_METADATA
 from bentoml._internal.container.frontend.dockerfile import CONTAINER_SUPPORTED_DISTROS
-from bentoml._internal.utils.pkg import get_local_bentoml_dependency
 from bentoml.exceptions import BentoMLConfigException
 from bentoml.exceptions import BentoMLException
 
+if t.TYPE_CHECKING:
+    from fs.base import FS
+
+    from bentoml._internal.bento.build_config import BentoEnvSchema
+
 if sys.version_info >= (3, 11):
     import tomllib
 else:
@@ -40,6 +45,7 @@ class Image:
     python_version: str = DEFAULT_PYTHON_VERSION
     commands: t.List[str] = attrs.field(factory=list)
     lock_python_packages: bool = True
+    pack_git_packages: bool = True
     python_requirements: str = ""
     post_commands: t.List[str] = attrs.field(factory=list)
     scripts: t.Dict[str, str] = attrs.field(factory=dict, init=False)
@@ -122,80 +128,135 @@ def run_script(self, script: str) -> t.Self:
         self.scripts[script] = target_script
         return self
 
-    def freeze(self, platform_: str | None = None) -> ImageInfo:
+    def freeze(
+        self, bento_fs: FS, envs: list[BentoEnvSchema], platform_: str | None = None
+    ) -> ImageInfo:
         """Freeze the image to an ImageInfo object for build."""
-        python_requirements = self._freeze_python_requirements(platform_)
-        return ImageInfo(
+        python_requirements = self._freeze_python_requirements(bento_fs, platform_)
+        from importlib import resources
+
+        from _bentoml_impl.docker import generate_dockerfile
+        from bentoml._internal.utils.filesystem import copy_file_to_fs_folder
+
+        # Prepare env/python files
+        py_folder = fs.path.join("env", "python")
+        bento_fs.makedirs(py_folder, recreate=True)
+        reqs_txt = fs.path.join(py_folder, "requirements.txt")
+        bento_fs.writetext(reqs_txt, python_requirements)
+        info = ImageInfo(
             base_image=self.base_image,
             python_version=self.python_version,
-            commands=["export UV_COMPILE_BYTECODE=1", *self.commands],
+            commands=self.commands,
             python_requirements=python_requirements,
             post_commands=self.post_commands,
-            scripts=self.scripts,
         )
-
-    def _freeze_python_requirements(self, platform_: str | None = None) -> str:
-        from tempfile import TemporaryDirectory
-
+        # Prepare env/docker files
+        docker_folder = fs.path.join("env", "docker")
+        bento_fs.makedirs(docker_folder, recreate=True)
+        dockerfile_path = fs.path.join(docker_folder, "Dockerfile")
+        bento_fs.writetext(
+            dockerfile_path,
+            generate_dockerfile(info, bento_fs, enable_buildkit=False, envs=envs),
+        )
+        for script_name, target_path in self.scripts.items():
+            copy_file_to_fs_folder(script_name, bento_fs, dst_filename=target_path)
+
+        with resources.path(
+            "bentoml._internal.container.frontend.dockerfile", "entrypoint.sh"
+        ) as entrypoint_path:
+            copy_file_to_fs_folder(str(entrypoint_path), bento_fs, docker_folder)
+        return info
+
+    def _freeze_python_requirements(
+        self, bento_fs: FS, platform_: str | None = None
+    ) -> str:
         from pip_requirements_parser import RequirementsFile
 
+        from bentoml._internal.bento.bentoml_builder import build_bentoml_sdist
+        from bentoml._internal.bento.build_config import PythonOptions
         from bentoml._internal.configuration import get_uv_command
 
-        with TemporaryDirectory(prefix="bento-reqs-") as parent:
-            requirements_in = Path(parent).joinpath("requirements.in")
-            requirements_in.write_text(self.python_requirements)
-            # XXX: RequirementsFile.from_string() does not work due to bugs
-            requirements_file = RequirementsFile.from_file(str(requirements_in))
-            has_bentoml_req = any(
-                req.name and req.name.lower() == "bentoml" and req.link is not None
-                for req in requirements_file.requirements
+        py_folder = fs.path.join("env", "python")
+        bento_fs.makedirs(py_folder, recreate=True)
+        requirements_in = Path(
+            bento_fs.getsyspath(fs.path.join(py_folder, "requirements.in"))
+        )
+        requirements_in.write_text(self.python_requirements)
+        py_req = fs.path.join("env", "python", "requirements.txt")
+        requirements_out = Path(bento_fs.getsyspath(py_req))
+        # XXX: RequirementsFile.from_string() does not work due to bugs
+        requirements_file = RequirementsFile.from_file(str(requirements_in))
+        has_bentoml_req = any(
+            req.name and req.name.lower() == "bentoml" and req.link is not None
+            for req in requirements_file.requirements
+        )
+        wheels_folder = fs.path.join("env", "python", "wheels")
+        with requirements_in.open("w") as f:
+            f.write(requirements_file.dumps(preserve_one_empty_line=True))
+            if not has_bentoml_req:
+                sdist_name = build_bentoml_sdist(bento_fs.getsyspath(wheels_folder))
+                bento_req = get_bentoml_requirement()
+                if bento_req is not None:
+                    logger.info(
+                        "Adding BentoML requirement to the image: %s.", bento_req
+                    )
+                    f.write(f"{bento_req}\n")
+                elif sdist_name is not None:
+                    f.write(f"./wheels/{sdist_name}\n")
+        if not self.lock_python_packages:
+            requirements_out.parent.mkdir(parents=True, exist_ok=True)
+            requirements_out.write_text(requirements_in.read_text())
+            PythonOptions.fix_dep_urls(
+                str(requirements_out),
+                bento_fs.getsyspath(wheels_folder),
+                self.pack_git_packages,
             )
-            with requirements_in.open("w") as f:
-                f.write(requirements_file.dumps(preserve_one_empty_line=True))
-                if not has_bentoml_req:
-                    req = get_bentoml_requirement() or get_local_bentoml_dependency()
-                    f.write(f"{req}\n")
-            if not self.lock_python_packages:
-                return requirements_in.read_text()
-            lock_args = [
-                str(requirements_in),
-                "--allow-unsafe",
-                "--no-header",
-                f"--output-file={requirements_in.with_suffix('.lock')}",
-                "--emit-index-url",
-                "--emit-find-links",
-                "--no-annotate",
-            ]
-            if get_debug_mode():
-                lock_args.append("--verbose")
-            else:
-                lock_args.append("--quiet")
-            logger.info("Locking PyPI package versions.")
-            if platform_:
-                lock_args.extend(["--python-platform", platform_])
-            elif platform.system() != "Linux" or platform.machine() != "x86_64":
-                logger.info(
-                    "Locking packages for %s. Pass `--platform` option to specify the platform.",
-                    DEFAULT_LOCK_PLATFORM,
-                )
-                lock_args.extend(["--python-platform", DEFAULT_LOCK_PLATFORM])
-            cmd = [*get_uv_command(), "pip", "compile", *lock_args]
-            try:
-                subprocess.check_call(
-                    cmd,
-                    text=True,
-                    stderr=subprocess.DEVNULL if get_quiet_mode() else None,
-                    cwd=parent,
-                )
-            except subprocess.CalledProcessError as e:
-                raise BentoMLException(f"Failed to lock PyPI packages: {e}") from None
-            locked_requirements = (  # uv doesn't preserve global option lines, add them here
-                "\n".join(option.dumps() for option in requirements_file.options)
+            return requirements_out.read_text()
+        lock_args = [
+            str(requirements_in),
+            "--allow-unsafe",
+            "--no-header",
+            f"--output-file={requirements_out}",
+            "--emit-index-url",
+            "--emit-find-links",
+            "--no-annotate",
+        ]
+        if get_debug_mode():
+            lock_args.append("--verbose")
+        else:
+            lock_args.append("--quiet")
+        logger.info("Locking PyPI package versions.")
+        if platform_:
+            lock_args.extend(["--python-platform", platform_])
+        elif platform.system() != "Linux" or platform.machine() != "x86_64":
+            logger.info(
+                "Locking packages for %s. Pass `--platform` option to specify the platform.",
+                DEFAULT_LOCK_PLATFORM,
             )
-            if locked_requirements:
-                locked_requirements += "\n"
-            locked_requirements += requirements_in.with_suffix(".lock").read_text()
-            return locked_requirements
+            lock_args.extend(["--python-platform", DEFAULT_LOCK_PLATFORM])
+        cmd = [*get_uv_command(), "pip", "compile", *lock_args]
+        try:
+            subprocess.check_call(
+                cmd,
+                text=True,
+                stderr=subprocess.DEVNULL if get_quiet_mode() else None,
+                cwd=bento_fs.getsyspath(py_folder),
+            )
+        except subprocess.CalledProcessError as e:
+            raise BentoMLException(f"Failed to lock PyPI packages: {e}") from None
+        locked_requirements = (  # uv doesn't preserve global option lines, add them here
+            "\n".join(option.dumps() for option in requirements_file.options)
+        )
+        if locked_requirements:
+            locked_requirements += "\n"
+        locked_requirements += requirements_out.read_text()
+        requirements_out.write_text(locked_requirements)
+        PythonOptions.fix_dep_urls(
+            str(requirements_out),
+            bento_fs.getsyspath(wheels_folder),
+            self.pack_git_packages,
+        )
+        return requirements_out.read_text()
 
 
 @attrs.define

src/bentoml/_internal/bento/bento.py

@@ -161,7 +161,7 @@ def check_fs(self, _attr: t.Any, new_fs: FS):
         else:
             self._model_store = ModelStore(models)
 
-    def __init__(self, tag: Tag, bento_fs: "FS", info: "BentoInfo"):
+    def __init__(self, tag: Tag, bento_fs: "FS", info: "BaseBentoInfo"):
         self._tag = tag
         self.__fs = bento_fs
         self.check_fs(None, bento_fs)
@@ -210,7 +210,8 @@ def get_manifest(self, dev: bool = False) -> BentoManifestSchema:
             ]
             image: ImageInfo | None = None
         else:
-            image = t.cast(ImageInfo, info.image)
+            assert isinstance(info, BentoInfoV2)
+            image = info.image
             runners = []
         return BentoManifestSchema(
             name=info.name,
@@ -440,9 +441,8 @@ def append_model(model: BentoModelInfo) -> None:
                 ),
                 envs=build_config.envs,
                 schema=svc.schema() if not is_legacy else {},
-                image=image.freeze(platform),
+                image=image.freeze(bento_fs, build_config.envs, platform),
             )
-            bento_info.image.write_to_bento(bento_fs, build_config.envs)
 
         res = Bento(tag, bento_fs, bento_info)
         if bare:
@@ -842,33 +842,6 @@ class ImageInfo:
     commands: t.List[str] = attr.field(factory=list)
     python_requirements: str = ""
     post_commands: t.List[str] = attr.field(factory=list)
-    scripts: t.Dict[str, str] = attr.field(factory=dict)
-
-    def write_to_bento(self, bento_fs: FS, envs: list[BentoEnvSchema]) -> None:
-        from importlib import resources
-
-        from _bentoml_impl.docker import generate_dockerfile
-
-        # Prepare env/python files
-        py_folder = fs.path.join("env", "python")
-        bento_fs.makedirs(py_folder, recreate=True)
-        reqs_txt = fs.path.join(py_folder, "requirements.txt")
-        bento_fs.writetext(reqs_txt, self.python_requirements)
-        # Prepare env/docker files
-        docker_folder = fs.path.join("env", "docker")
-        bento_fs.makedirs(docker_folder, recreate=True)
-        dockerfile_path = fs.path.join(docker_folder, "Dockerfile")
-        bento_fs.writetext(
-            dockerfile_path,
-            generate_dockerfile(self, bento_fs, enable_buildkit=False, envs=envs),
-        )
-        for script_name, target_path in self.scripts.items():
-            copy_file_to_fs_folder(script_name, bento_fs, dst_filename=target_path)
-
-        with resources.path(
-            "bentoml._internal.container.frontend.dockerfile", "entrypoint.sh"
-        ) as entrypoint_path:
-            copy_file_to_fs_folder(str(entrypoint_path), bento_fs, docker_folder)
 
 
 @attr.frozen(repr=False)

src/bentoml/_internal/bento/build_config.py

@@ -691,13 +691,21 @@ def write_to_bento(
                 )
             except subprocess.CalledProcessError as e:
                 raise BentoMLException(f"Failed to lock PyPI packages: {e}") from None
-            self._fix_dep_urls(pip_compile_out, bento_fs.getsyspath(wheels_folder))
+            self.fix_dep_urls(
+                pip_compile_out,
+                bento_fs.getsyspath(wheels_folder),
+                self.pack_git_packages,
+            )
         else:
             requirements_txt = bento_fs.getsyspath(
                 fs.path.combine(py_folder, "requirements.txt")
             )
             if os.path.exists(requirements_txt):
-                self._fix_dep_urls(requirements_txt, bento_fs.getsyspath(wheels_folder))
+                self.fix_dep_urls(
+                    requirements_txt,
+                    bento_fs.getsyspath(wheels_folder),
+                    self.pack_git_packages,
+                )
 
     def with_defaults(self) -> PythonOptions:
         # Convert from user provided options to actual build options with default values
@@ -708,7 +716,10 @@ def with_defaults(self) -> PythonOptions:
             return attr.evolve(self, lock_packages=False)
         return self
 
-    def _fix_dep_urls(self, requirements_txt: str, wheels_folder: str) -> None:
+    @staticmethod
+    def fix_dep_urls(
+        requirements_txt: str, wheels_folder: str, pack_git_packages: bool = True
+    ) -> None:
         """Replace the git dependencies in the requirements.lock file with the
         paths to the local copy.
         """
@@ -725,7 +736,7 @@ def _fix_dep_urls(self, requirements_txt: str, wheels_folder: str) -> None:
 
             if "/env/python/wheels" in link.url:
                 filename = link.filename
-            elif self.pack_git_packages and link.url.startswith("git+"):
+            elif pack_git_packages and link.url.startswith("git+"):
                 # We are only able to handle SSH Git URLs
                 url, ref = link.url_without_fragment[4:], ""
                 if "@" in link.path:  # ssh://git@owner/repo@ref

src/bentoml/_internal/container/frontend/dockerfile/templates/base_v2.j2

@@ -34,7 +34,11 @@ ENV PYTHONUNBUFFERED=1
 ARG BENTO_USER={{ bento__user }}
 ARG BENTO_USER_UID={{ bento__uid_gid }}
 ARG BENTO_USER_GID={{ bento__uid_gid }}
-RUN groupadd -g $BENTO_USER_GID -o $BENTO_USER && useradd -m -u $BENTO_USER_UID -g $BENTO_USER_GID -o -r $BENTO_USER
+RUN if command -v groupadd &>/dev/null; then \
+    groupadd -g $BENTO_USER_GID -o $BENTO_USER && useradd -m -u $BENTO_USER_UID -g $BENTO_USER_GID -o -r $BENTO_USER; \
+    else \
+    addgroup -g $BENTO_USER_GID -S $BENTO_USER && adduser -u $BENTO_USER_UID -G $BENTO_USER -S $BENTO_USER; \
+    fi
 {% endblock %}
 
 {% block SETUP_BENTO_ENVARS %}
@@ -74,7 +78,7 @@ ENV UV_COMPILE_BYTECODE=1
 
 COPY --chown={{ bento__user }}:{{ bento__user }} ./env/python ./env/python/
 # install python packages
-{% call common.RUN(__enable_buildkit__) -%} {{ __pip_cache__ }} {% endcall -%} uv pip install -r ./env/python/requirements.txt
+{% call common.RUN(__enable_buildkit__) -%} {{ __pip_cache__ }} {% endcall -%} uv --directory ./env/python/ pip install -r requirements.txt
 
 {% for command in __options__post_commands %}
 RUN {{ command }}