Problem (bug?) building docker image from Jenkins

Im trying to build a docker image from jenkins pipeline. This image sends some messages to RabbitMQ. When I build the image in the pipeline the container has the following error when the script is executed:

pika.exceptions.ProbableAccessDeniedError: ConnectionClosedByBroker: (530) 'NOT_ALLOWED - vhost oaoesvtq  not found'

I have a Jenkins master node and a agent node, the image is built in the agent node. Also if i access to the agent workspace in the node machine, and I build the image manually, the script works fine and there isn't any error.

Jenkins pipeline:

stage ('E2E Test'){
            environment {
                MONGODB_ENDPOINT = credentials("MONGODB_ENDPOINT")
                MONGODB_DATABASE = "sitas-test"
                //MINIO_INTERNAL_ENDPOINT = ${MINIO_INTERNAL_ENDPOINT}
                MINIO_INTERNAL_USER = credentials("MINIO_INTERNAL_USER")
                MINIO_INTERNAL_PASS = credentials("MINIO_INTERNAL_PASS")
                MINIO_INTERNAL_BUCKET = "internal-storage-test"
                //RABBITMQ_ENDPOINT = ${RABBITMQ_ENDPOINT}
                RABBITMQ_USER = credentials("RABBITMQ_USER")
                RABBITMQ_PASS = credentials("RABBITMQ_PASS")
                //RABBITMQ_VHOST = ${RABBITMQ_VHOST}
                RABBITMQ_QUEUE_DOWNLOADCOMPLETED = "sitas-test-queue-downloadcompleted"
                MINIO_NODE_ENDPOINT = "minio-oscarvx00.cloud.okteto.net"
                MINIO_NODE_USER = credentials("MINIO_INTERNAL_USER")
                MINIO_NODE_PASS = credentials("MINIO_INTERNAL_PASS")
                MINIO_NODE_BUCKET = "node-storage-test"
            }
            steps {
                dir('e2e'){
                    sh 'cp -r -a ../sources/containers/e2e-test/. ./'
                    unstash 'jarFile'
                    sh """ docker build --build-arg MONGODB_ENDPOINT="${MONGODB_ENDPOINT}" \
                                                                    --build-arg MONGODB_DATABASE="${MONGODB_DATABASE}" \
                                                                    --build-arg MINIO_INTERNAL_ENDPOINT="${MINIO_INTERNAL_ENDPOINT}" \
                                                                    --build-arg MINIO_INTERNAL_USER="${MINIO_INTERNAL_USER}" \
                                                                    --build-arg MINIO_INTERNAL_PASS="${MINIO_INTERNAL_PASS}" \
                                                                    --build-arg MINIO_INTERNAL_BUCKET="${MINIO_INTERNAL_BUCKET}" \
                                                                    --build-arg RABBITMQ_ENDPOINT="${RABBITMQ_ENDPOINT}" \
                                                                    --build-arg RABBITMQ_USER="${RABBITMQ_USER}" \
                                                                    --build-arg RABBITMQ_PASS="${RABBITMQ_PASS}" \
                                                                    --build-arg RABBITMQ_VHOST="${RABBITMQ_VHOST} "\
                                                                    --build-arg RABBITMQ_QUEUE_DOWNLOADCOMPLETED="${RABBITMQ_QUEUE_DOWNLOADCOMPLETED}" \
                                                                    --build-arg MINIO_NODE_ENDPOINT="${MINIO_NODE_ENDPOINT}" \
                                                                    --build-arg MINIO_NODE_USER="${MINIO_NODE_USER}" \
                                                                    --build-arg MINIO_NODE_PASS="${MINIO_NODE_PASS}" \
                                                                    --build-arg MINIO_NODE_BUCKET="${MINIO_NODE_BUCKET}" \
                                                                    --build-arg JAVA_HOME=/usr/lib/jvm/default-jvm \
                                                                    -t sitas-storagemanager-e2e .
                    """
                    
                    /*script{
                        docker.build("sitas-storagemanager-e2e", """--build-arg MONGODB_ENDPOINT="${MONGODB_ENDPOINT}" \
                                                                    --build-arg MONGODB_DATABASE="${MONGODB_DATABASE}" \
                                                                    --build-arg MINIO_INTERNAL_ENDPOINT="${MINIO_INTERNAL_ENDPOINT}" \
                                                                    --build-arg MINIO_INTERNAL_USER="${MINIO_INTERNAL_USER}" \
                                                                    --build-arg MINIO_INTERNAL_PASS="${MINIO_INTERNAL_PASS}" \
                                                                    --build-arg MINIO_INTERNAL_BUCKET="${MINIO_INTERNAL_BUCKET}" \
                                                                    --build-arg RABBITMQ_ENDPOINT="${RABBITMQ_ENDPOINT}" \
                                                                    --build-arg RABBITMQ_USER="${RABBITMQ_USER}" \
                                                                    --build-arg RABBITMQ_PASS="${RABBITMQ_PASS}" \
                                                                    --build-arg RABBITMQ_VHOST="${RABBITMQ_VHOST} "\
                                                                    --build-arg RABBITMQ_QUEUE_DOWNLOADCOMPLETED="${RABBITMQ_QUEUE_DOWNLOADCOMPLETED}" \
                                                                    --build-arg MINIO_NODE_ENDPOINT="${MINIO_NODE_ENDPOINT}" \
                                                                    --build-arg MINIO_NODE_USER="${MINIO_NODE_USER}" \
                                                                    --build-arg MINIO_NODE_PASS="${MINIO_NODE_PASS}" \
                                                                    --build-arg MINIO_NODE_BUCKET="${MINIO_NODE_BUCKET}" \
                                                                    -f Dockerfile .""").inside{
                                                                        sh "sh ./entrypoint.sh"
                                                                    }
                    }*/
                }
            }
        }

Dockerfile:

FROM amazoncorretto:17-alpine3.15
WORKDIR "/sitas-storagemanager-e2e-test"

RUN apk update
RUN apk add python3
RUN apk add py3-pip

COPY requirements.txt ./
RUN pip install -r requirements.txt

COPY e2etest.py ./
COPY 7f596b76.mp3 ./

COPY entrypoint.sh ./
RUN chmod +x entrypoint.sh

COPY *.jar ./

ARG MONGODB_ENDPOINT
ARG MONGODB_DATABASE
ARG MINIO_INTERNAL_ENDPOINT
ARG MINIO_INTERNAL_USER
ARG MINIO_INTERNAL_PASS
ARG MINIO_INTERNAL_BUCKET
ARG RABBITMQ_ENDPOINT
ARG RABBITMQ_USER
ARG RABBITMQ_PASS
ARG RABBITMQ_VHOST
ARG RABBITMQ_QUEUE_DOWNLOADCOMPLETED
ARG MINIO_NODE_ENDPOINT
ARG MINIO_NODE_USER
ARG MINIO_NODE_PASS
ARG MINIO_NODE_BUCKET

ENV MONGODB_ENDPOINT=${MONGODB_ENDPOINT}
ENV MONGODB_DATABASE=${MONGODB_DATABASE}
ENV MINIO_INTERNAL_ENDPOINT=${MINIO_INTERNAL_ENDPOINT}
ENV MINIO_INTERNAL_USER=${MINIO_INTERNAL_USER}
ENV MINIO_INTERNAL_PASS=${MINIO_INTERNAL_PASS}
ENV MINIO_INTERNAL_BUCKET=${MINIO_INTERNAL_BUCKET}
ENV RABBITMQ_ENDPOINT=${RABBITMQ_ENDPOINT}
ENV RABBITMQ_USER=${RABBITMQ_USER}
ENV RABBITMQ_PASS=${RABBITMQ_PASS}
ENV RABBITMQ_VHOST=${RABBITMQ_VHOST}
ENV RABBITMQ_QUEUE_DOWNLOADCOMPLETED=${RABBITMQ_QUEUE_DOWNLOADCOMPLETED}
ENV MINIO_NODE_ENDPOINT=${MINIO_NODE_ENDPOINT}
ENV MINIO_NODE_USER=${MINIO_NODE_USER}
ENV MINIO_NODE_PASS=${MINIO_NODE_PASS}
ENV MINIO_NODE_BUCKET=${MINIO_NODE_BUCKET}

What can I do to avoid the error if the data source is the same for jenkins and for the manual build but one container has an error and the other not??

Thanks.