Alpaquita Linux: Debugging apps running in Docker with JetBrains and VSCode: Java, C, and Python

$ git clone https://github.com/spring-projects/spring-petclinic.git

# Create a stage for resolving and downloading dependencies.
FROM bellsoft/liberica-openjdk-alpine:21 AS deps

# Download dependencies as a separate step to take advantage of Docker's
# caching.
WORKDIR /build

COPY --chmod=0755 mvnw mvnw
COPY .mvn/ .mvn/

RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 \
	./mvnw dependency:go-offline -DskipTests


# Create a stage for building the application based on the stage with
# downloaded dependencies.
FROM deps AS package

WORKDIR /build
COPY ./src src/
RUN --mount=type=bind,source=pom.xml,target=pom.xml \
    --mount=type=cache,target=/root/.m2 \
    ./mvnw package -DskipTests && \
    mv target/$(./mvnw help:evaluate -Dexpression=project.artifactId \
		-q -DforceStdout)-$(./mvnw help:evaluate -Dexpression=project.version \
		-q -DforceStdout).jar \
		target/app.jar


# Create a stage for extracting the application into separate layers.
FROM package AS extract

WORKDIR /build

RUN java -Djarmode=layertools -jar target/app.jar \
		extract --destination target/extracted

# Create a new stage for running the application that contains the minimal
# runtime dependencies. We use liberica-openjre-alpine:21
# because there is no need to use a full blown JDK just to run the app.
FROM bellsoft/liberica-openjre-alpine:21 AS final

# Create a non-privileged user that the app will run under.
ARG UID=10001
RUN adduser \
    --disabled-password \
    --gecos "" \
    --home "/nonexistent" \
    --shell "/sbin/nologin" \
    --no-create-home \
    --uid "${UID}" \
    appuser
USER appuser

# Copy the executable from the "package" stage.
COPY --from=extract build/target/extracted/dependencies/ ./
COPY --from=extract build/target/extracted/spring-boot-loader/ ./
COPY --from=extract build/target/extracted/snapshot-dependencies/ ./
COPY --from=extract build/target/extracted/application/ ./

# Expose 8080, as we will use this as the application port.
EXPOSE 8080

# Specifying the command that will executed when the container starts.
ENTRYPOINT [ "java", "org.springframework.boot.loader.launch.JarLauncher" ]

$ cd spring-petclinic
$ docker build --tag petclinic-liberica .

-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005

# Change this to your production image
FROM petclinic-liberica

# Add command line option for enabling JDWP debugging server
ENV JAVA_TOOL_OPTIONS="${JAVA_TOOL_OPTIONS} \
	-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005"

$ docker build --tag petclinic-liberica-debug -f Dockerfile.debug .
$ docker run -p8080:8080 -p5005:5005 petclinic-liberica-debug
Picked up JAVA_TOOL_OPTIONS:  -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:5005
Listening for transport dt_socket at address: 5005
...

$ curl -s \
	--request GET \
	--url 'http://localhost:8000/solve_quadratic?a=1&b=-8&c=15' \
	| jq

{
  "x1": 5.0,
  "x2": 3.0
}

from fastapi import FastAPI, HTTPException
from math import sqrt
from typing import Dict

app = FastAPI()

@app.get("/solve_quadratic")
def solve_quadratic(a: float, b: float = 0, c: float = 0) -> Dict[str, float]:
    if a == 0:
        raise HTTPException(status_code=400,
			detail="Coefficient 'a' cannot be zero.")

    discriminant = b**2 - 4*a*c

    if discriminant < 0:
        raise HTTPException(status_code=400,
			detail="No real solutions, discriminant is negative.")

	# Bug introduced here: it should be (2 * a)
    x1 = (-b + sqrt(discriminant)) / (2 * c)
    x2 = (-b - sqrt(discriminant)) / (2 * c)

    if x1 == x2:
        return {"x": x1}

    return {"x1": x1, "x2": x2}

FROM bellsoft/alpaquita-linux-python:3.12-musl

# Print log messages immediately instead of them being buffered
ENV PYTHONUNBUFFERED=1

WORKDIR /src

# Activate virtual environment
ENV VIRTUAL_ENV=/src/.venv
ENV PATH="$VIRTUAL_ENV/bin:$PATH"
RUN python3 -m venv $VIRTUAL_ENV

# Install dependencies:
COPY requirements.txt .
RUN pip3 install -r requirements.txt

# Copy source code
COPY src/ .

# Start the uvicorn web server. 8000 is the default port
CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0"]

fastapi
uvicorn

$ docker build --tag fastapi-app .

$ docker run -it reverser:latest
noel sees leon
Reversed string:
noel sees leon

#include <string.h>
#include <stdio.h>


/* reverse:  reverse string s in place */
void reverse(char s[]) {
    int n = strlen(s);

	for (int i = 0,j = n - 1; i < j; i++, j--) {
        char tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }
}

/* main: get string from stdin, reverse and print it */
int main() {
    char str[256];
	fgets(str, sizeof(str), stdin);

	reverse(str);
	printf("Reversed string: %s\n", str);
}

CC = gcc
SRC_DIR = src
BUILD_DIR := build
CFLAGS = -Wall -Wextra -O2

BIN = reverser

main: $(BUILD_DIR)/$(BIN)

$(BUILD_DIR)/$(BIN): $(SRC_DIR)/main.c
	@mkdir -p $(BUILD_DIR)
	$(CC) $(CFLAGS) -o $@ $<


clean:
	rm -rf $(BUILD_DIR)

.PHONY: main clean

FROM bellsoft/alpaquita-linux-gcc:14.2-musl AS build
WORKDIR /build
# Copy src and Makefile
COPY src src
COPY Makefile .
# Compile the app
RUN make

# Use a lightweight base for final image
FROM bellsoft/alpaquita-linux-base:stream-musl
WORKDIR /app
# Follow best practices and use a non-root user
RUN adduser -D user
USER user
# Copy the binary
COPY --from=build /build/build/reverser .
# Execute the binary
ENTRYPOINT ["./reverser"]

#include <string.h>
#include <stdio.h>

/* reverse:  reverse string s in place */
void reverse(char s[]) {
    int n = strlen(s);

	for (int i = 0,j = n - 1; i < j; i++, j--) {
        char tmp = s[i];
        s[i] = s[j];
        s[j] = tmp;
    }
}

/* reverse: print reversed string from args */
int main(const int argc, char *argv[]) {
    /* We accept only one argument.If we receive more or less than one
    argument, exit with error */
    if (argc != 1) {
        fprintf(stderr, "Usage: ./reverser <string>\n");
        return 1;
    }

    // If we receive a too long string, exit
    if (strlen(argv[1]) > 256) {
        fprintf(stderr, "%s", "String too long\n");
        return 1;
    }
    // Copy the argument into a string
    char str[256];
    strncpy(str, argv[1], sizeof(str) - 1);

	reverse(str);
	printf("Reversed string: %s\n", str);
}

$ docker build --tag reverser-arg .
[+] Building 0.8s (15/15) FINISHED
...
$ docker run --rm -it reverser-arg:latest "noel sees leon"
Usage: ./reverser <string>

CC = gcc
CFLAGS = -Wall -Wextra
SRC_DIR = src
BUILD_DIR = build
BIN = reverser

DEBUG ?= 0
ifeq ($(DEBUG), 1)
	CFLAGS := $(CFLAGS) -g -O0
	BUILD_DIR := $(BUILD_DIR)-debug
	BIN := $(BIN).debug
else
	CFLAGS := $(CFLAGS) -O3
endif

main: $(BUILD_DIR)/$(BIN)

$(BUILD_DIR)/$(BIN): $(SRC_DIR)/main.c
	@mkdir -p $(BUILD_DIR)
	$(CC) $(CFLAGS) -o $@ $<

clean:
	rm -rf $(BUILD_DIR)

.PHONY: main clean

FROM bellsoft/alpaquita-linux-gcc:14.2-musl AS build

WORKDIR /build
COPY Makefile .
COPY src src
# compile the code with debugging symbols
RUN make DEBUG=1


FROM bellsoft/alpaquita-linux-base:stream-musl
WORKDIR /app
# Install gdb package
RUN apk update && apk add --no-cache gdb
COPY --from=build /build/build-debug/reverser.debug .
COPY --from=build /build/src src
# Start gdbserver on port 2159 to debug the application
ENTRYPOINT ["gdbserver", ":2159","./reverser.debug"]

$ docker build --tag reverser-arg-debug -f Dockerfile.debug .

$ docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \
    -p2159:2159 reverser-arg-debug:latest "noel sees leon"

Process ./reverser.debug created; pid = 9
Listening on port 2159