Pre-install extensions on Dockerfile

[fspaniol]

Hi there, I've found some similar threads at #171 and #2658 , however they don't seem to be active anymore.

My idea was to ship a custom Docker image with some extensions already pre-installed. So I tried this out:

FROM codercom/code-server:4.0.1

RUN code-server --install-extension golang.go

This built successfully, however, when I executed my Docker image, no extensions were there.

I tried then to add this in the form of a CMD, first installing the extension and then starting the executable, something like:

FROM codercom/code-server:4.0.1

ENTRYPOINT [ "bash" ]
CMD ["code-server", "--install-extension", "golang.Go", "&&", "code-server" ]

But it always always saying that it couldn't find the binary.

So, in the end, what I had to do to get this working, was to create a small entrypoint script, which looks like the following:

#!/bin/bash

code-server --install-extension golang.Go

code-server --auth none --host=0.0.0.0 --port=8080

And the Dockerfile:

FROM codercom/code-server:4.0.1
COPY "entrypoint.sh" /
ENTRYPOINT [ "/entrypoint.sh" ]

Can anyone maybe help me understand what's going on here?

[jsjoeio]

I agree, we should have docs on this. @bpmct has helped me with this in the past personally. Let me ping him and see if he can help.

@code-asher might have some suggestions.

After we get that, I can add a guide to the docs to help with this.

[fspaniol]

First off, thanks for the prompt reply :D

Hmmm, I actually tried it with multiple extensions, none of them worked. And the fact that with the entrypoint it did work, makes me think that this is unlikely to be the issue.

About the PATH though, it does find the binary and it seems that it can ship correctly. What I have noticed, however, is that the home folder of the Docker (namely /home/coder) is always erased when I start the container (even if I, for example, add some vsix files there in the Dockerfile). It's a long shot, but maybe that has something to deal with this?

[jsjoeio]

the home folder of the Docker (namely /home/coder) is always erased when I start the container

That's very odd 🤔 @code-asher is this expected?

[fspaniol]

Maybe I should add that I'm running on kubernetes, using the helm distribution with persistence disabled

[im-coder-lg]

I know this answer would fail, but has anyone checked rclone? I mean, extensions might linger, who knows?

[jsjoeio]

Maybe I should add that I'm running on kubernetes, using the helm distribution with persistence disabled

cc @bpmct in case you has any ideas.

[code-asher]

Do you mount anything to the container? I wonder if the extensions are installed into that directory then a mount is made on top, maybe to /home/coder since you say it is getting reset so you are seeing the host directory instead of the one in the image.

[fspaniol]

I don't actively do so, maybe the helm chart does it?

I found this: https://github.com/coder/code-server/blob/main/ci/helm-chart/templates/deployment.yaml#L80

[code-asher]

Ahh yeah that could be it!

Looking at the docs it seems the recommendation is to use
extraInitContainers to install extensions:

https://github.com/coder/code-server/blob/439f27c5685d3aeba158269d162f1bf800482295/docs/helm.md#extra-containers

[fspaniol]

Yeah, that's what I was trying to avoid :(

This way, every time I spin up a pod, it will install the extension on startup, which may take a while. I wanted to do that in the build phase so that I don't have this extra delay when starting code instances. Maybe I'm being too optimistic thinking this is possible?

[code-asher]

The main idea I have is to change where code-server looks for
extensions. So for example pass some directory outside the home that
does not get mounted like --extensions-dir /extensions or something.

If you want to keep the extensions in the home directory the two ideas I
have are to override the mount settings so it does not mount the whole
home directory (I am not familiar enough with Helm to know if that is
possible) or to install them in a different directory like above but
then symlink them as part of the init.

[RodogInfinite]

I'm running Singularity for my container application, but I think the solution may transfer; although, I have a feeling it's not a perfect solution due to the unpredictable naming extensions can have, but it should at least reduce the number of extensions that install whenever the container runs. For Singularity there is a %runscript section that runs every time I start the container. It's been years since I've used Docker so I'm not quite sure what the equivalent would be.

In my container definition file I have:

Bootstrap: docker
From: debian:buster

%post
# Install basic packages, like curl. Application specific so they're not listed here

# Install Code-Server
curl -fsSL https://code-server.dev/install.sh | sh

# Install Pip3 and the toml package. The toml package will be used in the Python script every time the container runs.
apt install -y python3-pip
pip3 install toml

%runscript
# Run the Python script for installing extensions
cd /path/to/dir/with/script
python3 configure-code-server.py

# Starts the code-server instance
code-server

This isn't strictly necessary, but I have a config.toml file that users can configure to skip the installation of extensions process altogether whenever the container is run. In the toml file I define install_extensions=true.

In my configure-code-server.py file I have:

from pathlib import Path
import subprocess
import os
import signal
import toml

# Define paths
config_file = Path("config.toml")

code_server_dir = Path("/root/.local/share/code-server/")
code_server_extensions_dir = code_server_dir / "extensions" # My script does more than this example so that's why this extra step exists
default_extensions_dir = Path("/path/to/extensions/holding/directory") # This should contain the default .vsix extensions that will be included in code server


if code_server_dir.exists() is False:
    # Run Code-Server instance to create necessary directories from its internal setup process
    p = subprocess.Popen(["code-server"],shell=False,preexec_fn=os.setsid)
    # Seems to be the onlyway to kill the signal without generating zombie instances of code-server
    os.kill(p.pid,signal.SIGINT)

if config_file.exists():
    print("Parsing config.toml...")
    parsed_toml = toml.load(config_file)

if parsed_toml["install_extensions"] is True:
    p = subprocess.Popen(["code-server","--list-extensions"],stdout=subprocess.PIPE,stderr=None)
    # Generate a list of extension name strings for those that are already installed
    installed_extensions = p.communicate()[0].decode("utf-8").split("\n")
    
    extensions = list(default_extensions_dir.glob('*.vsix'))

    print("Checking extensions...")
    for installed_extension_path in installed_extensions:
        for extension in extensions:
            # Remove the extensions directory prefix and split on the '.' to split the publisher from the extension name
            installed_extension = str(installed_extension_path).strip("extensions/").split(".")
            # Use the extension name to make the comparision to the current extension
            if len(installed_extension) >=2 and installed_extension[1] in str(extension):
                # Extension is already installed. Remove it so that it isn't installed again
                extensions.remove(extension)
                break
    if extensions:
        print("\nMissing extensions found...")
        for extension in extensions:
            # Run Code-Server --install-extension <extension> to install all extensions remaining in the list
            p = subprocess.Popen(["code-server","--install-extension",str(extension)],shell=False)
            time.sleep(2)
    else:
        print("No extensions to install")

It would be really convenient if this behavior could be included in code-server directly instead of needing this. Something like code-server --install-extensions /path/to/extensions/dir where it iteratively installs every extension in that directory if it isn't already installed

[RodogInfinite]

I'm currently trying to figure out if there's a way to get extensions installed in the %post section during the build process to persist to the instances ran after building. This would allow them to be installed once during the build and the Python script will not need to be executed every time a new instance of the container is ran. If I do the following:

Bootstrap: docker
From: debian:buster

%post
# Install basic packages, like curl. Application specific so they're not listed here

# Install Code-Server
curl -fsSL https://code-server.dev/install.sh | sh

# Install Pip3 and the toml package. The toml package will be used in the Python script every time the container runs.
apt install -y python3-pip
pip3 install toml

# Run the Python script for installing extensions
cd /path/to/dir/with/script
python3 configure-code-server.py

%runscript
# Starts the code-server instance
code-server

The output to the terminal during building is:

+ python3 configure-code-server.py
Checking extensions...

Missing extensions found...
Installing extensions...
Extension 'onnovalkering.vscode-singularity-0.6.0.vsix' was successfully installed.
Installing extensions...
Extension 'just-preview.just-preview-0.0.1.vsix' was successfully installed.
Installing extensions...
Extension 'cesium.gltf-vscode-2.3.13.vsix' was successfully installed.
Installing extensions...
Extension 'rust-analyzer-linux-x64.vsix' was successfully installed.
Done

but they are not available in a running instance and navigating to /root/.local/share/code-server/extensions in the code-server terminal shows it as an empty directory

[P.S.] After about an hour I put this down. I have a working solution and have other things that need attention. I may revisit this in the future and will make an update if I solve it.

[fspaniol]

Actually, after coming back to it after some time, I managed to get my use case going, even with Docker. I think the issue that I had previously was related to me using the Helm chart which would, as stated earlier, mount some folders on top of the path that I was installing my own extension.

My current Dockerfile is something similar to this:

FROM node:alpine AS builder

RUN npm install -g vsce

WORKDIR /usr/app
COPY ./ /usr/app

RUN yarn install && \
    vsce package

FROM codercom/code-server:4.0.1 AS release

COPY --from=builder /usr/app/*.vsix /my-extension.vsix

RUN ["code-server", "--install-extension", "/my-extension.vsix"]

COPY "entrypoint.sh" /
ENTRYPOINT [ "/entrypoint.sh" ]

And the entrypoint:

#!/bin/bash

code-server --auth none --host=0.0.0.0 --port=8080