How to fix /bin/sh: 1: mycommand: not found in Docker

First, determine exactly what command is missing. Check your Dockerfile's CMD or ENTRYPOINT instruction and note which executable is failing.

If the error mentions '/bin/sh' itself is not found, you're using a base image without a shell (like scratch). If it's '/bin/sh: 1: mycommand: not found', the shell exists but can't find your command.

Run this to inspect your image and check what's actually in it:

docker run --rm -it your-image-name ls /bin

If this fails with the same error, your base image is too minimal to support shell commands.

If you're using FROM scratch or other minimal base images, switch from shell form to exec form in your Dockerfile. This removes the dependency on /bin/sh.

Before (shell form - requires /bin/sh):

CMD myapp --port 8080

After (exec form - direct binary execution):

CMD ["myapp", "--port", "8080"]

The exec form passes arguments as a JSON array and Docker executes the binary directly without invoking a shell. This works with scratch and distroless images.

Similarly for ENTRYPOINT:

ENTRYPOINT ["/app/myapp"]
CMD ["--config", "/etc/config.yaml"]

If your application needs specific utilities, install them during the image build. For Alpine Linux base images:

FROM alpine:3.19

# Install common utilities
RUN apk add --no-cache bash curl wget git

# Install your application dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . /app
WORKDIR /app
CMD ["python", "app.py"]

For Debian/Ubuntu images:

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
    curl \
    git \
    wget \
 && rm -rf /var/lib/apt/lists/*

Make sure installations happen before you try to use the commands.

If you're copying a binary into your image, either place it in a directory that's already in PATH, or update PATH to include your binary's location.

Option 1: Copy to standard location

COPY myapp /usr/local/bin/myapp
RUN chmod +x /usr/local/bin/myapp
CMD ["myapp"]

Option 2: Update PATH environment variable

COPY myapp /app/bin/myapp
RUN chmod +x /app/bin/myapp
ENV PATH="/app/bin:$PATH"
CMD ["myapp"]

Option 3: Use absolute path

COPY myapp /app/myapp
RUN chmod +x /app/myapp
CMD ["/app/myapp"]

Note the chmod +x command to ensure execute permissions are set.

In multi-stage builds, files from earlier stages don't automatically carry over. If you installed binaries in an earlier stage, you must explicitly copy them to the final stage.

# Build stage
FROM golang:1.21 AS builder
WORKDIR /build
COPY . .
RUN go build -o myapp

# Final stage - scratch has no shell/utilities
FROM scratch
# Copy the binary from builder stage
COPY --from=builder /build/myapp /myapp
ENTRYPOINT ["/myapp"]

If your app needs shared libraries, copy those too:

FROM alpine:3.19 AS final
COPY --from=builder /build/myapp /usr/local/bin/myapp
COPY --from=builder /lib/x86_64-linux-gnu/libc.so.6 /lib/x86_64-linux-gnu/
CMD ["myapp"]

If you're running shell scripts, ensure the shebang line matches available interpreters in your container.

Check what's available in your base image:

docker run --rm alpine:3.19 ls -l /bin/sh /bin/bash

Alpine has /bin/sh but not /bin/bash by default. Update your scripts:

Before:

#!/bin/bash
echo "Hello"

After (for Alpine):

#!/bin/sh
echo "Hello"

Or install bash in your Dockerfile:

RUN apk add --no-cache bash

Volumes can overlay directories in your image. If you mount a volume at /app and your binary is in /app/myapp, the volume will hide the binary.

Problematic docker-compose.yml:

volumes:
  - ./src:/app  # This hides everything in /app from the image

Solution 1: Mount at subdirectory

volumes:
  - ./src:/app/src  # Only overlay the src subdirectory

Solution 2: Keep binaries outside mounted path

COPY myapp /usr/local/bin/myapp
WORKDIR /app
# Now mounting at /app won't hide the binary