Snippets Collections
Un ejemplo real donde puedes usar Promise.all con async/await es cuando necesitas hacer múltiples operaciones asíncronas en paralelo y esperar a que todas terminen antes de continuar. Por ejemplo, en el caso de una aplicación que debe obtener información de varios usuarios desde diferentes endpoints de una API y luego procesar todos esos datos juntos.

Imagina que tienes que traer datos de dos usuarios distintos al mismo tiempo. Usando Promise.all con async/await puedes lanzar ambas solicitudes al mismo tiempo y esperar a que ambas terminen antes de continuar:

javascript
async function obtenerDatosUsuarios() {
  async function getUser(userId) {
    const response = await fetch(`https://api.miapi.com/user/${userId}`);
    const userData = await response.json();
    return userData;
  }

  try {
    const [usuario1, usuario2] = await Promise.all([getUser(1), getUser(2)]);
    console.log('Datos de usuario 1:', usuario1);
    console.log('Datos de usuario 2:', usuario2);
    // Aquí puedes trabajar con ambos datos al mismo tiempo
  } catch (error) {
    console.error('Error al obtener datos de usuarios:', error);
  }
}

obtenerDatosUsuarios();
En esta situación, si alguna de las dos solicitudes falla, el Promise.all se rechaza inmediatamente y entras en el bloque catch para manejar el error. Esto es eficiente porque no esperas a terminar una solicitud para empezar la otra, sino que ambas se pagan en paralelo y el programa espera a que las dos terminen para continuar. Además, puedes manejar fácilmente el error si alguna de las solicitudes falla.

Otro caso real puede ser enviar un lote de correos electrónicos a muchos usuarios en paralelo, procesándolos por lotes para no saturar el servidor. En cada lote usas Promise.all para esperar que se terminen de enviar los correos antes de pasar al siguiente grupo.

Así, Promise.all con async/await es útil para operaciones asíncronas que pueden ejecutarse en paralelo y donde se requiere que todas concluyan satisfactoriamente para continuar.
1. Promise.all con async/await:Espera a que todas las promesas se resuelvan. Si alguna promesa es rechazada, se rechaza inmediatamente con el motivo del primer error.

async function ejemploPromiseAll() {
  const p1 = Promise.resolve(3);
  const p2 = 1337; // valor normal, se acepta directamente
  const p3 = new Promise(resolve => setTimeout(resolve, 100, "foo"));

  try {
    const resultados = await Promise.all([p1, p2, p3]);
    console.log(resultados); // [3, 1337, "foo"]
  } catch (error) {
    console.error("Error:", error);
  }
}
ejemploPromiseAll();

2. Promise.any con async/await: Resuelve cuando la primera promesa se resuelve exitosamente. Rechaza solo si todas las promesas son rechazadas.

async function ejemploPromiseAny() {
  const p1 = Promise.reject("Error 1");
  const p2 = new Promise(resolve => setTimeout(resolve, 100, "Éxito 2"));
  const p3 = new Promise(resolve => setTimeout(resolve, 200, "Éxito 3"));

  try {
    const resultado = await Promise.any([p1, p2, p3]);
    console.log(resultado); // "Éxito 2"
  } catch (error) {
    console.error("Todas las promesas fallaron:", error);
  }
}
ejemploPromiseAny();

3. Promise.race con async/await: Resuelve o rechaza tan pronto como la primera promesa se resuelva o rechace.
async function ejemploPromiseRace() {
  const p1 = new Promise(resolve => setTimeout(resolve, 500, "Resultado p1"));
  const p2 = new Promise((_, reject) => setTimeout(reject, 100, "Error p2"));

  try {
    const resultado = await Promise.race([p1, p2]);
    console.log(resultado);
  } catch (error) {
    console.error("Error del primero en terminar:", error); // "Error p2"
  }
}
ejemploPromiseRace();

4. Promise.allSettled con async/await: Espera a que todas las promesas terminen (resueltas o rechazadas) y devuelve un array con el estado y valor o razón de cada promesa.

async function ejemploPromiseAllSettled() {
  const p1 = Promise.resolve("Éxito p1");
  const p2 = Promise.reject("Error p2");
  const p3 = Promise.resolve("Éxito p3");

  const resultados = await Promise.allSettled([p1, p2, p3]);

  resultados.forEach((result, index) => {
    if (result.status === "fulfilled") {
      console.log(`Promesa ${index + 1} cumplida con valor: ${result.value}`);
    } else {
      console.log(`Promesa ${index + 1} rechazada con razón: ${result.reason}`);
    }
  });
}
ejemploPromiseAllSettled();
Antes de la introducción de async y await en JavaScript, el manejo de operaciones asíncronas con promesas se hacía principalmente usando los métodos .then() y .catch() de las promesas. Estos métodos permitían encadenar funciones que se ejecutaban cuando la promesa se resolvía o se rechazaba, respectivamente. Por ejemplo:
miPromesa()
  .then(resultado => {
    // manejar resultado exitoso
  })
  .catch(error => {
    // manejar error
  });
1. Promise.all
Espera a que todas las promesas se resuelvan. Si alguna promesa es rechazada, se rechaza inmediatamente con el motivo del primer error.

const p1 = Promise.resolve(3);
const p2 = 1337; // No es promesa, se acepta tal cual en el array de resultados
const p3 = new Promise((resolve) => setTimeout(resolve, 100, "foo"));

Promise.all([p1, p2, p3]).then(values => {
  console.log(values); // [3, 1337, "foo"]
}).catch(error => {
  console.error(error);
});

2. Promise.any
Resuelve cuando la primera promesa se resuelve exitosamente. Rechaza solo si todas las promesas son rechazadas.

const p1 = Promise.reject("Error 1");
const p2 = new Promise((resolve) => setTimeout(resolve, 100, "Éxito 2"));
const p3 = new Promise((resolve) => setTimeout(resolve, 200, "Éxito 3"));

Promise.any([p1, p2, p3]).then(value => {
  console.log(value); // "Éxito 2"
}).catch(error => {
  console.error(error); // Se ejecutaría si todas las promesas fallan
});

3.-3. Promise.race
Resuelve o rechaza tan pronto como la primera promesa se resuelva o rechace.
const p1 = new Promise((resolve) => setTimeout(resolve, 500, "Resultado p1"));
const p2 = new Promise((_, reject) => setTimeout(reject, 100, "Error p2"));

Promise.race([p1, p2]).then(value => {
  console.log(value);
}).catch(error => {
  console.error(error); // "Error p2", ya que es la primera en finalizar con rechazo
});

4. Promise.allSettled
Espera a que todas las promesas terminen (resueltas o rechazadas) y devuelve un array con el estado y valor o razón de cada promesa.

const p1 = Promise.resolve("Éxito p1");
const p2 = Promise.reject("Error p2");
const p3 = Promise.resolve("Éxito p3");

Promise.allSettled([p1, p2, p3]).then(results => {
  results.forEach((result, index) => {
    if (result.status === "fulfilled") {
      console.log(`Promesa ${index + 1} cumplida con valor: ${result.value}`);
    } else {
      console.log(`Promesa ${index + 1} rechazada con razón: ${result.reason}`);
    }
  });
});
<style>
        .dialog {
            display: none;
            position: fixed;
            left: 0;
            top: 0;
            width: 100%;
            height: 100%;
            background-color: rgba(0, 0, 0, 0.5);
            z-index: 1000;
        }
        .dialog-content {
            background-color: white;
            margin: 15% auto;
            padding: 20px;
            border-radius: 5px;
            width: 80%;
            max-width: 500px;
        }
    </style>
1.-<dialog id="myDialog" class="dialog">
      <div class="dialog-content">
          <h2>Dialog Title</h2>
          <p>This is a dialog box.</p>
          <button onclick="myDialog.close()">Close</button>
          <button onclick="myDialog.showModal()">Abrir Modal</button>
      </div>
	</dialog>
<script>
  const myDialog = document.getElementById('myDialog');
</script>

<button onclick="myDialog.showModal()">abrir Modal</button>
    
2.-<button id="openDialog">Abrir diálogo</button>

<dialog id="myDialog">
  <p>Este es un cuadro de diálogo</p>
  <button id="closeDialog">Cerrar</button>
</dialog>

<script>
  const openDialogButton = document.getElementById("openDialog");
  const dialog = document.getElementById("myDialog");
  const closeDialogButton = document.getElementById("closeDialog");

  openDialogButton.addEventListener("click", () => {
    dialog.showModal(); // Muestra el cuadro de diálogo en modo modal
  });

  closeDialogButton.addEventListener("click", () => {
    dialog.close(); // Cierra el cuadro de diálogo
  });
</script>
Aquí tienes ejemplos específicos para cada paso de crear contenedores Docker y conectarlos, explicados de forma que sea fácil recordarlos:

1.-Descargar la imagen
Comando:
docker pull nginx:latest
Esto descarga la imagen oficial de Nginx con la etiqueta "latest" desde Docker Hub. Si no especificas la etiqueta, se toma "latest" por defecto.

2.-Crear una red personalizada
Comando:

docker network create mired
Aquí creas una red llamada "mired" de tipo bridge, donde podrás conectar varios contenedores para que se comuniquen entre sí.

3.-Crear el contenedor con configuración
Comando ejemplo:

docker run -d --name mi_nginx -p 8080:80 -e "ENV=production" --network mired nginx:latest
Explicación:

-d: ejecuta el contenedor en segundo plano.
--name mi_nginx: asigna el nombre "mi_nginx" al contenedor.
-p 8080:80: expone el puerto 80 del contenedor en el puerto 8080 del host.
-e "ENV=production": define la variable de entorno ENV con valor production.
--network mired: conecta el contenedor a la red personalizada creada.
nginx:latest: usa la imagen nginx con la etiqueta latest.

4.-Conectar contenedores entre sí
Supongamos que creas dos contenedores en la red "mired":

docker run -d --name webapp --network mired nginx
docker run -d --name db --network mired mysql -e MYSQL_ROOT_PASSWORD=password
Ambos están en la misma red, por lo que el contenedor "webapp" puede acceder al "db" usando el nombre "db" como hostname.

Si quieres conectar un contenedor ya existente a la red después de crearlo:

docker network connect mired nombre_contenedor
Para recordar mejor cada paso, piensa:

"Pull" es traer la imagen al disco.

"Network create" es como hacer una calle para que los contenedores se hablen.

"Run" es poner en marcha el contenedor con nombre, puertos, y variables.

Ponerlos en la misma red es para que cooperen sin problemas.
Aquí tienes un resumen detallado y ordenado de los pasos para crear contenedores Docker y conectarlos, incluyendo descarga de imágenes, creación de redes, configuración de contenedores con puertos, nombres, variables de entorno y asignación de redes:

Descargar la imagen

Usar el comando docker pull nombre_imagen:etiqueta para descargar una imagen desde un repositorio (como Docker Hub).

Si no se especifica etiqueta, se descarga la etiqueta "latest" por defecto.

También puedes dejar que Docker la descargue automáticamente al crear un contenedor si la imagen no está local.

Crear una red personalizada (opcional)

Los contenedores por defecto se conectan a una red bridge predeterminada, pero puedes crear una red propia para una mejor gestión.

Comando para crear red tipo bridge: docker network create nombre_red

Esta red permitirá luego conectar contenedores entre sí fácilmente.

Crear el contenedor con configuración

Usar docker run para crear y ejecutar un contenedor.

Algunos parámetros útiles para configurar al crear el contenedor:

-p puerto_local:puerto_contenedor: Asigna y mapea puertos del host al contenedor.

--name nombre_contenedor: Asigna un nombre legible y gestionable al contenedor.

-e VAR=valor: Define variables de entorno para configurar la aplicación dentro del contenedor.

--network nombre_red: Conecta el contenedor a la red creada previamente o a la red deseada.

imagen:etiqueta: Especifica la imagen y la etiqueta (versión) que se usará.

Ejemplo del comando completo para crear un contenedor con esos parámetros:

bash
docker run -d --name mi_contenedor -p 8080:80 -e "API_KEY=abc123" --network mired mi_imagen:1.0
Esto creará un contenedor en segundo plano (-d), con nombre mi_contenedor, exponiendo el puerto 80 del contenedor en el puerto 8080 del host, definiendo una variable de entorno API_KEY, conectándolo a la red mired y usando la imagen mi_imagen con etiqueta 1.0.

Conectar contenedores entre sí

Si los contenedores están en la misma red personalizada, podrán comunicarse mediante sus nombres.

Para conectar contenedores existentes a una red, usar docker network connect nombre_red nombre_contenedor.

Estos pasos te permiten crear y configurar contenedores Docker con la flexibilidad para gestionar puertos, entornos, nombres y redes, lo cual es esencial para proyectos que involucren múltiples contenedores y servicios interconectados.
Opciones comunes incluyen:
-a o --all: Muestra todas las imágenes, incluidas las intermedias.
-q o --quiet: Muestra solo los IDs de las imágenes.
--filter: Filtra las imágenes según condiciones específicas.
--format: Formatea la salida de acuerdo con una plantilla personalizada.

si te sale este error hacer:
permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock
significa que tu usuario no tiene permiso para acceder al socket del daemon de Docker. Esto es común cuando Docker se instala y se usa sin permisos elevados o sin configurar el usuario adecuadamente.

Para solucionar esto, tienes dos opciones:
1.-Usar sudo temporalmente para ejecutar comandos Docker, por ejemplo:
sudo docker images
Esto funciona pero no es lo ideal a largo plazo porque cada comando Docker requeriría sudo.

2.-Configurar tu usuario para que pertenezca al grupo "docker", que tiene acceso al socket de Docker. Ejecuta estos comandos:

-Crea el grupo docker si no existe:
sudo groupadd docker

-Agrega tu usuario al grupo docker (reemplaza ${USER} por tu nombre de usuario o mantén la variable si estás en una terminal):
sudo usermod -aG docker ${USER}

-Para que los cambios tengan efecto, cierra la sesión de tu usuario y vuelve a iniciarla, o ejecuta:
su - ${USER}

-Ahora deberías poder ejecutar comandos Docker sin sudo, por ejemplo:
docker images

-Si sigues teniendo problemas, asegúrate de que el permiso del directorio .docker en tu home sea correcto con:
sudo chown "$USER":"$USER" ~/.docker -R
sudo chmod g+rwx ~/.docker -R
Con este procedimiento, el acceso al socket Docker debe quedar configurado para tu usuario y el error desaparecerá.
1.-Preparar el entorno base:
Instala Docker y Docker Compose en tu sistema para poder construir y manejar contenedores.

2.-Crear estructura de proyecto Laravel:
Puedes crear el proyecto Laravel localmente o usar un contenedor PHP con Composer para generarlo.
Si ya tienes un proyecto Laravel, colócalo en una carpeta donde trabajes con Docker.

3.-Crear archivo Dockerfile para PHP + Apache2 + extensiones relevantes:
Usarás la imagen base oficial de PHP 8.4 con Apache.
Instalarás las extensiones necesarias para Laravel y PostgreSQL, por ejemplo: pdo_pgsql, pgsql, zip, curl, xml, mbstring.
Copiarás el código fuente Laravel al contenedor.
Ejemplo básico de Dockerfile:
FROM php:8.4-apache

RUN apt-get update && apt-get install -y \
    libpq-dev \
    libzip-dev \
    zip \
    unzip \
    && docker-php-ext-install pdo_pgsql pgsql zip bcmath

COPY . /var/www/html/

RUN chown -R www-data:www-data /var/www/html \
    && a2enmod rewrite
    
4.-Configurar Docker Compose para los servicios:
Define servicios para PHP-Apache y PostgreSQL.
Vincula volúmenes para código y datos persistentes.
Configura variables de entorno para Laravel (DB connection).
Ejemplo básico de docker-compose.yml:
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:80"
    volumes:
      - ./:/var/www/html
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: laravel
      POSTGRES_USER: laraveluser
      POSTGRES_PASSWORD: laravelpass
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

5.-Configurar archivo .env de Laravel:
Ajusta las variables para conectarse a la base de datos PostgreSQL dentro del contenedor:

DB_CONNECTION=pgsql
DB_HOST=db
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=laravelpass

6.-Construir e iniciar los contenedores Docker:
En la terminal, ejecutar:
docker-compose up --build
Esto facilita manejar dependencias y la base de datos dentro del entorno Docker.

Resumen y conceptos clave:
Dockerfile: define cómo construir la imagen personalizada PHP+Apache con las extensiones necesarias.
Docker Compose: orquesta múltiples contenedores (app y db), redes y volúmenes.
Volúmenes: aseguran que tu código y los datos de la base de datos persistan fuera de los contenedores.
Laravel .env: configura la conexión a la base de datos PostgreSQL dentro de la red Docker.
Comandos Artisan dentro del contenedor mantienen el entorno controlado y consistente.
Este proceso modular te permite entender cómo Docker puede contenerizar un proyecto web completo con backend, webserver y base de datos separados pero comunicados, facilitando el desarrollo y pruebas locales sin alterar tu sistema nativo.
nohup celery -A mysite worker --loglevel=info > celery_worker.log &
nohup celery -A mysite beat --loglevel=info > celery_beat.log &
docker system prune [OPTIONS]
--all , -a		Remove all unused images not just dangling ones
--filter		API 1.28+
Provide filter values (e.g. 'label=<key>=<value>')
--force , -f		Do not prompt for confirmation
--volumes		Prune volumes
docker-compose run --rm frontend sh -c 'npx create-react-app プロジェクト名 --template typescript'
q
//show images
docker images

//show volumes
docker volume ls

//check if the volume is attached to any container:
docker ps -a --filter volume=<volume_name>
  
// remove volume
docker volume rm <volume_name>
  
//automatically delete unused volumes
docker volume prune

//upack mongo.tar with volume to the directory
tar -xvf mongo.tar -C /path/to/mongo-data

//run docker container from image with attached volume
//mongodb_dm - volume name
//mongo - container name
docker run -d --name mongo -v mongodb_dm:/data/db -p 27017:27017 mongo:latest
docker run -d --name mongo -v mongodb_dm:/data/db -p 27017:27017 mongo:4.4
// with attached volume
docker run -d --name mongo -v /path/to/mongo-data:/data/db -p 27017:27017 mongo:4.4
docker run -d --name mongo -v mongo:/data/db -p 27017:27017 mongo:4.4

// run shel inside the container
docker exec -it mongo mongo
// with attached volume and auth
docker run -d --name mongo -v /path/to/mongo-data:/data/db -p 27017:27017 mongo:4.4 --auth
docker exec -it mongo mongo -u "admin" -p "yourpassword" --authenticationDatabase "admin"

docker inspect <container_id>

//enter into container
docker exec -it <container ID> bash

//build daemon
docker-compose up --build -d

docker stop <container ID>
docker rm <container ID>


//postgres with attached volume(directory)
docker run -d --name postgres -e POSTGRES_USER=<user> -e POSTGRES_PASSWORD=<password> -p 5432:5432 -v /path/to/postgres:/var/lib/postgresql/data postgres:14


FROM php:8.2-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    && docker-php-ext-install zip

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user
// show dir inside image
docker run --rm -it --entrypoint=/bin/bash imagename
FROM python:3.11-slim


# Create a non-root user to run the app as
RUN addgroup --system app && adduser --system --group app

# Environment variables
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=off \
    PIP_DISABLE_PIP_VERSION_CHECK=on \
    PIP_DEFAULT_TIMEOUT=100 \
    POETRY_VIRTUALENVS_IN_PROJECT=true \
    # Set Poetry to NOT install the dependencies into a virtual environment, instead install them into the system's Python environment
    POETRY_VIRTUALENVS_CREATE=false \
    POETRY_NO_INTERACTION=1 \
    PYTHONPATH=${PYTHONPATH}:${PWD}

# Make a directory for the project
RUN mkdir /app

# Change to the `/app` directory
WORKDIR /app

# Copy the project files over to the container
COPY pyproject.toml /app
COPY . /app

# Chown all the files to the app user
RUN chown -R app:app /app

# Install Poetry
RUN pip3 install poetry

# Export the Poetry pack list to another format
RUN poetry export -f requirements.txt > requirements.txt

# Install the Python dependencies
RUN poetry install --only main

# Become the `app` user
USER app

# Expose port 8000 on the container
EXPOSE 8000

#CMD ["poetry", "run", "gunicorn"]
CMD ["gunicorn"]
docker exec -it <container_id> bash
docker run --privileged -idt kindest/node:v1.21.2
docker build -t imagename bath dockerfilename
FROM golang:alpine as builder

label "maintainer"="amirabbasmehvari@gmail.com"
RUN mkdir /app
WORKDIR /app/
COPY . /app/
RUN go build -o main .

FROM alpine
COPY --from=builder /app/main /app/
WORKDIR /app/
CMD ["./main"]
FROM php:8.1-fpm

RUN apt-get update

COPY . /app
RUN ls -l
RUN php -v
CMD php /app/index.php




















docker image ls
docker images
docker image history imagename
docker build -t imagename:version path
FROM ubuntu:18.04

RUN apt-get update
RUN apt-get install -y curl

COPY . /app

RUN ls -l

CMD python /app/app.py










docker build -t imagename:version path
create mysql container
for find server of the mysql run command :
docker container inspect mysql
find Networks.brigde.IpAddress
copy ip address and use 
docker container ls -a
docker images
docker pull image
docker container run -exec -it --rm --name container-name image bash
docker container run -exec -it --name container-name image bash
docker container exec -it container-name bash
docker ps
docker container inspect container-name
docker container stats
docker container top container-name
docker container pause container-name
docker container unpause container-name
docker container stop
docker container cp file-path container-name:path

// The mysql container is reading from the wrong DB port.

// While 127.0.0.1 might work in the DB client, Docker might have trouble with this. 

// Change the DB_HOST value to your local network's IP as returned by the ifconfig command
// Docker is unable to map the mysql folder containing the socket file.

// Change the following line in the volumes property of your db container in the docker-compose.yml from
- 'sail-mysql:/var/lib/mysql' 

// to 
'- '${MYSQL_DOCKER_FOLDER}:/var/lib/mysql'

// The corresponding env variable might hold something like MYSQL_DOCKER_FOLDER=./mysql

// Create the "mysql" folder at the root of the file
// Follow the instructions in the following video: https://www.youtube.com/watch?v=iHad9TH9mOA&ab_channel=Tuto1902

// Then add the following to your /docker/8.2/ext-xdebug.ini
xdebug.log=/var/log/xdebug.log
xdebug.log_level=3

// Add the following to the Dockerfile
RUN touch /var/log/xdebug.log \
    && chmod 766 /var/log/xdebug.log

docker run -d -p 80 --restart unless-stopped nginx
docker ps # current containers
docker run # create and start the container
docker create # create container
dokcer exec # to run commnads in container for once
docker volume # create a docker volume
docker network # create a docker network
docker rm # remove container 
docker images # list the images
docker rmi # remove image
docker build # build a new image from dockerfile
docker push # push your image to docker repo
docker pull # download an image from docker repo
docker commit # create an image from container
docker-compose down # Stop container on current dir if there is a docker-compose.yml
docker rm -fv $(docker ps -aq) # Remove all containers
sudo lsof -i -P -n | grep <port number> # List who's using the port
# sudo kill -9 <process id> (macOS)
# sudo kill <process id> (Linux)
docker run -d \
   -v /etc/timezone:/etc/timezone:ro \  
   -v /etc/localtime:/etc/localtime:ro \
   ...
#Copy the image

$ docker pull doctorkirk/oracle-19c

#Create local directory

$ mkdir -p /your/custom/path/oracle-19c/oradata
$ cd /your/custom/path/
$ sudo chown -R 54321:54321 oracle-19c/

#Run the Container

docker run --name oracle-19c \
  -p 1521:1521 \
  -e ORACLE_SID=[ORACLE_SID] \
  -e ORACLE_PWD=[ORACLE_PASSWORD] \
  -e ORACLE_CHARACTERSET=[CHARSET] \
  -v /your/custom/path/oracle-19c/oradata/:/opt/oracle/oradata \
doctorkirk/oracle-19c

#Charset: WE8MSWIN1252(*default), AL16UTF8, US7ASCI
#* If omitted in docker run , the default characterset for this build will be WE8MSWIN1252.
docker run -d --restart=always \
        --name oracle \
        --privileged  \
        -e ORACLE_SID=<custom sid> \
        -v /srv/oradata:/u01/app/oracle \
        -p 8080:8080 -p 1521:1521 \
 absolutapps/oracle-12c-ee
docker run -e 'ACCEPT_EULA=Y' \
    -e 'MSSQL_SA_PASSWORD=<YourStrong!Passw0rd>' \
    -p 1433:1433 -v <host directory>/data:/var/opt/mssql/data \
    -v <host directory>/log:/var/opt/mssql/log \
    -v <host directory>/secrets:/var/opt/mssql/secrets \
    -d mcr.microsoft.com/mssql/server:2019-latest
sudo mkdir -p /your/custom/path/oracle-19c/oradata/
sudo chmod -R 777 /your/custom/path/

docker run -d --name oracle19db \
  -p 1521:1521 \
  -e ORACLE_SID=ORCL \
  -e ORACLE_PDB=ORCLDB \
  -e ORACLE_PWD=Oracle123 \
  -e ORACLE_CHARSET=AL32UTF8 \
  -v /your/custom/path/oracle-19c/oradata:/opt/oracle/oradata \
  banglamon/oracle193db:19.3.0-ee

# Charset Value: WE8MSWIN1252, AL16UTF8

# ALTER SESSION SET NLS_DATE_FORMAT = 'RRRR-MM-DD';
# ALTER SESSION SET NLS_TIME_FORMAT = 'HH24:MI:SS';
# ALTER SESSION SET NLS_TIMESTAMP_FORMAT = 'RRRR-MM-DD HH24:MI:SS';
# ALTER SESSION SET NLS_TIME_TZ_FORMAT = 'HH24:MI:SS TZR';
# ALTER SESSION SET NLS_TIMESTAMP_TZ_FORMAT = 'RRRR-MM-DD HH24:MI:SS TZR';

# docker exec -it oracle19db bash -c "source /home/oracle/.bashrc; sqlplus /nolog”
# connect sys as sysdba;

# alter session set "_ORACLE_SCRIPT"=true;
# create user sistemas identified by las36horas;
# GRANT CONNECT, RESOURCE, DBA TO sistemas;
# GRANT UNLIMITED TABLESPACE TO sistemas;
$> docker pull haskell
$> docker run -it haskell stack <parameters>


$> git clone https://github.com/jean-lopes/dfm-to-json.git

$> cd dfm-to-json

$> stack setup
$> stack install
$> dfm-to-json --version
#put your databases on /svr/fb-databases

docker run -d --name fb -p 3050:3050 -v /srv/fb-databases:/db almeida/firebird

#connect using localhost:3050:db/<database file>.gdb
:> docker run -it --name fb --rm -v ~/tmp:/tmp almeida/firebird gbak -b -v 192.168.1.251:c:/host/path/database.fdb /tmp/backup.bak -user sysdba -pass XXXXX
Dozzle for Docker, error view
docker exec -it mongo <command>
# RUN TO CREATE A NEW PROJECT
# docker run --rm -v `pwd`:/var/www/html pimcore/pimcore:PHP8.0-fpm composer create-project pimcore/skeleton my-project

cd ./{NAME_OF_THE_PROJECT_FOLDER}

docker-compose up -d

# TO RUN ONLY WITH A LOCAL DATABASE.
# docker-compose exec php-fpm vendor/bin/pimcore-install --mysql-host-socket=db --mysql username=pimcore --mysql-password=pimcore --mysql-database=pimcore

docker-compose exec php-fpm composer install

docker-compose exec php-fpm chown -R www-data:www-data var

docker inspect -f '{{range $key, $value := .NetworkSettings.Networks}}{{$key}} {{end}}' [container]
docker inspect -f '{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_name_or_id
version: '3.8'

services:
  fastapi_api:
    build:
      context: ./<path to Dockerfile>
    # the 'app.main' part of the next line assumes your main.py file is in a folder named 'app'
    command: gunicorn app.main:app --bind 0.0.0.0:5000 -w 2 -k uvicorn.workers.UvicornWorker
    ports:
      # host:container
      - "8000:5000"
FROM python:3.11-rc-slim

ENV WORKDIR=/usr/src/app
ENV USER=app
ENV APP_HOME=/home/app/web
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1

WORKDIR $WORKDIR

RUN pip install --upgrade pip
COPY ./requirements.txt $WORKDIR/requirements.txt
RUN pip install -r requirements.txt

RUN adduser --system --group $USER
RUN mkdir $APP_HOME
WORKDIR $APP_HOME

COPY . $APP_HOME
RUN chown -R $USER:$USER $APP_HOME
USER $USER
/* clone repo */
git clone ...

/* docker up */
docker-compose up -d

/* Install pimcore dependencies*/
docker exec -it php-fpm /bin/bash
composer install

/* Install pimcore and define local db */
docker-compose exec php-fpm vendor/bin/pimcore-install --mysql-host-socket=db --mysql-username=pimcore --mysql-password=pimcore --mysql-database=pimcore

/* change owner to ./var folder */
docker-compose exec php-fpm chown -R www-data:www-data var
RewriteCond %{HTTPS} !=on
RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
REWRITERULE ^(.*)$ http://dockerbackend/$1 [P]
//Commmand prompt 
wsl --list -v

//Expected output
//  NAME                   STATE           VERSION
//* docker-desktop         Running         2
//  docker-desktop-data    Running         2

wsl  --shutdown

mkdir D:\Docker\wsl\data\ //your path

wsl --export docker-desktop-data "D:\Docker\wsl\data\docker-desktop-data.tar"

wsl --unregister docker-desktop-dat

awsl --import docker-desktop-data "D:\Docker\wsl\data" "D:\Docker\wsl\data\docker-desktop-data.tar" --version 2


//Delete the exported .tar file: D:\Docker\wsl\data\docker-desktop-data.tar and nothing more!
docker ps //List running containers
docker ps --all //List all containers
docker system prune //Remove unused data
docker system prune --all //Remove all unused images not just dangling ones
docker run {IMAGE} //combining 'docker create' & 'docker start'
docker run -d {IMAGE} // Run container in background and print container ID
docker run -p {systemport}:{dockerport} {IMAGE} // Map Port of the OS to the dockerport
docker run -it {IMAGE} //Input output
docker run -it {IMAGE} sh //Run docker container and shell into it
docker exec -it {IMAGE} sh //Shell into running docker container
docker build . //Build docker image with random id 
docker build -t {REPO}/{TAGNAME} . //Build docker image with random id 
docker stop {IMAGE} //Stop container from running

docker-compose up //Execute docker compose
docker-compose up --build // Rebuild Docker container and execute docker compose
docker-compose -d {IMAGE} // Run container in background and print container ID
docker-compose down //Stop container from running
kubectl rollout restart deploy -n cnext-di-demo
## Dockerfile
FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

## EOF Dockerfile

## docker-compose.yaml
# Docker compose for PHP, Composer and nginx
# Check Dockerfile to create app image, PHP 7.4 and Composer
# Run: docker-compose up
# After mounted, open container cli 
# 
# Update laravel packages:
##### composer update
# Restart container to apply nginx configuration
##### docker compose restart 

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: my-app
    container_name: myapp-php
    restart: always
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - webdev

  nginx:
    image: nginx:alpine
    container_name: myapp-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./nginx.conf:/etc/nginx/conf.d/default.conf
    networks:
      - webdev

networks:
  webdev:
    driver: bridge
    
## EOF docker-compose.yml

## create a nginx.conf file in the root of your app
## nginx.conf

server {
    listen 80;
    index index.php index.html;
    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;
    root /var/www/public;
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

## EOF nginx.conf


Run: 
docker-compose up

When container is up open container console (cli)
composer update
docker compose restart

docker build -t <image-name>
  
docker run -d -p <public-port>:<image-port> <image-name>
  
docker run -it <image-name> sh
docker ps //List running containers
docker ps --all //List all containers
docker system prune //Remove unused data
docker system prune --all //Remove all unused images not just dangling ones
docker run {IMAGE} //combining 'docker create' & 'docker start'
docker run -d {IMAGE} // Run container in background and print container ID
docker run -p {systemport}:{dockerport} {IMAGE} // Map Port of the OS to the dockerport
docker run -it {IMAGE} //Input output
docker run -it {IMAGE} sh //Run docker container and shell into it
docker exec -it {IMAGE} sh //Shell into running docker container
docker build . //Build docker image with random id 
docker build -t {REPO}/{TAGNAME}. //Build docker image with random id 
docker stop {IMAGE} //Stop container from running

docker-compose up //Execute docker compose
docker-compose up --build // Rebuild Docker container and execute docker compose
docker-compose -d {IMAGE} // Run container in background and print container ID
docker-compose down //Stop container from running
docker login -u AWS -p <password> -e none https://<aws_account_id>.dkr.ecr.<region>.amazonaws.com
docker build -t imagename -f Dockerfile2 .
# install docker
sudo apt-get install docker.io

# create and run a container from an image from the Docker Hub
sudo docker run --name firstContainer ubuntu:latest # where firstContainer is the name of the container

# list locally available docker containers
sudo docker ps -a

# open a docker container in interactive mode in the terminal
sudo docker run -it --name myContainer ubuntu:latest # where myContainer is the container name
# you can exit the container by pressing CTRL+P and CTRL+Q

# attach container to terminal
sudo docker attach myContainer # the container will now stay open in the background even after exiting via CTRL+P and CTRL+Q

# execute commands in the container running in the background
sudo docker exec myContainer echo $PATH

# delete containers
sudo docker rm -f firstContainer myContainer

# create new docker image based on your local environment/container
sudo docker commit myNginx docker_id/image_name # where myNginx is the name of your currently running container

# create new docker container from an image from a previously committed image
sudo docker run -it --name nginxNew docker_id/image_name

# list images on your machine
sudo docker image ls

# login to your docker hub account from the terminal
sudo docker login # you will be prompted to enter your id and password

# push an image to docker hub when logged into your docker account
sudo docker push docker_id/image_name

# run a docker container in the background
sudo docker run -d --name myApp nginx

# start an interactive bash terminal for the container running in the background
sudo docker exec -it myApp bashapt-get

# stop a running container
sudo docker stop myApp

# start a stopped container again
sudo docker start myApp
docker exec -it postgres psql -U postgres -d postgres -c 'SELECT * FROM "dataelement"'
-- create the databases
CREATE DATABASE IF NOT EXISTS projectone;

-- create the users for each database
CREATE USER 'projectoneuser'@'%' IDENTIFIED BY 'somepassword';
GRANT CREATE, ALTER, INDEX, LOCK TABLES, REFERENCES, UPDATE, DELETE, DROP, SELECT, INSERT ON `projectone`.* TO 'projectoneuser'@'%';

FLUSH PRIVILEGES;
rsync через docker'овский туннель гонять вот так: rsync -e 'docker exec -i' --blocking-io -rv CONTAINER_NAME:/data ., главное не забыть добавить --blocking-io.
version: '2.1'

services:
  zoo1:
    image: zookeeper:3.4.9
    hostname: zoo1
    ports:
      - "2181:2181"
    environment:
        ZOO_MY_ID: 1
        ZOO_PORT: 2181
        ZOO_SERVERS: server.1=zoo1:2888:3888
    volumes:
      - ./zk-single-kafka-single/zoo1/data:/data
      - ./zk-single-kafka-single/zoo1/datalog:/datalog

  kafka1:
    image: confluentinc/cp-kafka:5.5.0
    hostname: kafka1
    ports:
      - "9092:9092"
    environment:
      KAFKA_ADVERTISED_LISTENERS: LISTENER_DOCKER_INTERNAL://kafka1:19092,LISTENER_DOCKER_EXTERNAL://${DOCKER_HOST_IP:-127.0.0.1}:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: LISTENER_DOCKER_INTERNAL:PLAINTEXT,LISTENER_DOCKER_EXTERNAL:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: LISTENER_DOCKER_INTERNAL
      KAFKA_ZOOKEEPER_CONNECT: "zoo1:2181"
      KAFKA_BROKER_ID: 1
      KAFKA_LOG4J_LOGGERS: "kafka.controller=INFO,kafka.producer.async.DefaultEventHandler=INFO,state.change.logger=INFO"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
    volumes:
      - ./zk-single-kafka-single/kafka1/data:/var/lib/kafka/data
    depends_on:
      - zoo1
$ docker run -d \
  --name realopinsight \
  --network host \
  --publish 4583:4583 \
  rchakode/realopinsight
star

Thu Aug 14 2025 20:07:56 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 19:51:58 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 19:47:04 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 18:45:07 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 14:05:02 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 14:00:35 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 13:46:48 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Aug 14 2025 13:10:31 GMT+0000 (Coordinated Universal Time)

#php #laravel #docker #compose
star

Mon May 19 2025 02:29:47 GMT+0000 (Coordinated Universal Time)

#seid #docker #rust
star

Thu Sep 05 2024 07:12:34 GMT+0000 (Coordinated Universal Time) https://www.google.com/search?q

#shell #docker
star

Wed Jul 31 2024 08:02:28 GMT+0000 (Coordinated Universal Time) https://qiita.com/91works-i-kato/items/9f9ad03fee32d42ed547

#react #type #docker
star

Thu Apr 18 2024 19:38:43 GMT+0000 (Coordinated Universal Time)

#docker #mongodb #postgres
star

Tue Jan 16 2024 03:13:04 GMT+0000 (Coordinated Universal Time)

#docker
star

Sat Jan 13 2024 08:09:40 GMT+0000 (Coordinated Universal Time)

#docker
star

Sat Jul 22 2023 23:20:25 GMT+0000 (Coordinated Universal Time)

#python #fastapi #poetry #docker
star

Thu Jun 08 2023 16:59:03 GMT+0000 (Coordinated Universal Time) https://chat.openai.com/

#k8s #docker #bash
star

Thu Jun 08 2023 16:58:09 GMT+0000 (Coordinated Universal Time) https://chat.openai.com/

#bash #k8s #docker
star

Tue Mar 28 2023 07:53:37 GMT+0000 (Coordinated Universal Time)

#docker
star

Tue Mar 28 2023 07:52:34 GMT+0000 (Coordinated Universal Time)

#docker #multi-builder
star

Mon Mar 27 2023 09:27:56 GMT+0000 (Coordinated Universal Time)

#docker #php
star

Mon Mar 27 2023 09:13:54 GMT+0000 (Coordinated Universal Time)

#docker #php
star

Mon Mar 27 2023 08:33:41 GMT+0000 (Coordinated Universal Time)

#docker #wordpress
star

Mon Mar 27 2023 08:29:05 GMT+0000 (Coordinated Universal Time)

#docker #wordpress
star

Mon Mar 27 2023 08:28:32 GMT+0000 (Coordinated Universal Time)

#docker #wordpress
star

Sun Mar 26 2023 05:01:38 GMT+0000 (Coordinated Universal Time)

#docker #wordpress
star

Sat Mar 25 2023 10:25:48 GMT+0000 (Coordinated Universal Time)

#docker
star

Thu Feb 09 2023 20:35:12 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/65213171/disable-xdebug-3-could-not-connect-message-in-cli

#docker
star

Mon Jan 23 2023 09:12:00 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/51445846/elasticsearch-max-virtual-memory-areas-vm-max-map-count-65530-is-too-low-inc

#elasticsearch #docker #kibana
star

Fri Oct 28 2022 03:43:40 GMT+0000 (Coordinated Universal Time) https://www.educative.io/module/page/LgoqGKFl7YxO2wNDm/10370001/5453871022342144/5091147352375296

#docker #restart #fail
star

Tue Oct 25 2022 16:12:41 GMT+0000 (Coordinated Universal Time) https://www.educative.io/

#docker #run #port
star

Thu Sep 08 2022 22:33:02 GMT+0000 (Coordinated Universal Time) https://www.google.com/search?q

#whatever #docker #grepper #google-search
star

Thu Sep 08 2022 18:14:59 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/37971961/docker-error-bind-address-already-in-use

#bash #docker
star

Tue Aug 30 2022 13:55:53 GMT+0000 (Coordinated Universal Time)

#docker
star

Mon Aug 29 2022 19:51:25 GMT+0000 (Coordinated Universal Time)

#bash #docker #oracle
star

Mon Aug 29 2022 19:08:02 GMT+0000 (Coordinated Universal Time)

#bash #docker
star

Mon Aug 29 2022 18:38:18 GMT+0000 (Coordinated Universal Time)

#bash #docker
star

Mon Aug 29 2022 18:33:43 GMT+0000 (Coordinated Universal Time)

#sql #bash #docker
star

Mon Aug 29 2022 18:30:27 GMT+0000 (Coordinated Universal Time)

#bash #docker #delphi
star

Mon Aug 29 2022 18:29:43 GMT+0000 (Coordinated Universal Time)

#docker
star

Mon Aug 29 2022 18:13:16 GMT+0000 (Coordinated Universal Time)

#bash #docker
star

Wed Jul 06 2022 09:34:01 GMT+0000 (Coordinated Universal Time)

#docker
star

Tue Jul 05 2022 23:30:51 GMT+0000 (Coordinated Universal Time)

#docker
star

Wed Mar 23 2022 14:56:15 GMT+0000 (Coordinated Universal Time)

#pimcore #docker #docker-compose
star

Thu Mar 03 2022 16:05:26 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/41928729/docker-failed-to-register-layer

#commandline #docker
star

Thu Mar 03 2022 16:05:05 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/41928729/docker-failed-to-register-layer

#commandline #docker
star

Wed Feb 02 2022 21:40:50 GMT+0000 (Coordinated Universal Time) https://maximorlov.com/4-reasons-why-your-docker-containers-cant-talk-to-each-other/

#docker #networking
star

Wed Feb 02 2022 21:40:14 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/17157721/how-to-get-a-docker-containers-ip-address-from-the-host

#docker #networking
star

Wed Feb 02 2022 21:24:13 GMT+0000 (Coordinated Universal Time)

#docker #ssh
star

Mon Jan 31 2022 02:16:16 GMT+0000 (Coordinated Universal Time)

#python #fastapi #docker
star

Mon Jan 31 2022 02:15:50 GMT+0000 (Coordinated Universal Time)

#python #fastapi #docker
star

Mon Jan 17 2022 08:34:07 GMT+0000 (Coordinated Universal Time)

#docker #pimcore
star

Tue Jan 04 2022 21:27:35 GMT+0000 (Coordinated Universal Time)

#ssl #letsencrypt #linux #cyberpanel #docker
star

Thu Dec 23 2021 09:36:46 GMT+0000 (Coordinated Universal Time)

#docker #win10
star

Mon Dec 06 2021 20:40:02 GMT+0000 (Coordinated Universal Time)

#docker
star

Mon Dec 06 2021 11:49:55 GMT+0000 (Coordinated Universal Time) https://blog.codetitans.pl/post/howto-docker-over-wsl2-location/

#docker #wsl2
star

Wed Dec 01 2021 08:41:07 GMT+0000 (Coordinated Universal Time)

#powershell #docker #pods #restart
star

Tue Nov 16 2021 11:37:21 GMT+0000 (Coordinated Universal Time)

#docker #nginx #php #phpfm
star

Thu Oct 07 2021 12:02:59 GMT+0000 (Coordinated Universal Time)

#docker
star

Fri Oct 01 2021 11:30:05 GMT+0000 (Coordinated Universal Time)

#docker
star

Fri Aug 13 2021 08:16:38 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/29600369/starting-and-populating-a-postgres-container-in-docker

#docker
star

Tue Jul 20 2021 07:40:25 GMT+0000 (Coordinated Universal Time) https://www.youtube.com/watch?v

#zeet #deploy #docker
star

Wed Jul 07 2021 19:25:34 GMT+0000 (Coordinated Universal Time)

#docker #aws
star

Wed Apr 28 2021 08:20:00 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/32997269/copying-a-file-in-a-dockerfile-no-such-file-or-directory

#docker
star

Sat Apr 10 2021 05:55:14 GMT+0000 (Coordinated Universal Time)

#linux #docker
star

Fri Mar 19 2021 15:46:23 GMT+0000 (Coordinated Universal Time)

#docker #psql
star

Wed Feb 24 2021 20:06:09 GMT+0000 (Coordinated Universal Time) https://stackoverflow.com/questions/43322033/create-database-on-docker-compose-startup

#sql #docker
star

Sun Nov 29 2020 16:44:07 GMT+0000 (Coordinated Universal Time) https://forums.docker.com/t/start-a-gui-application-as-root-in-a-ubuntu-container/17069

#bash #docker #ubuntu
star

Wed Oct 14 2020 17:12:11 GMT+0000 (Coordinated Universal Time) https://habr.com/ru/post/277699/

#docker #shell
star

Wed Oct 07 2020 20:56:30 GMT+0000 (Coordinated Universal Time) https://github.com/zircote/swagger-php

#docker #swagger #php
star

Sun Jun 21 2020 12:42:52 GMT+0000 (Coordinated Universal Time) https://github.com/simplesteph/kafka-stack-docker-compose

#kafka #docker
star

Sat Jun 20 2020 22:57:14 GMT+0000 (Coordinated Universal Time) https://github.com/rchakode/realopinsight

#k8s #docker #tools

Save snippets that work with our extensions

Available in the Chrome Web Store Get Firefox Add-on Get VS Code extension