desde un container docker A comuunicarse con un container B

ambos contenedores deben estar en la misma red docker

1. crear la red
2. conectar un container a la red
3. al container invocar al contenedor con http:// , osea http://nombre-contenedor:99999 , 99999 es el puerto

---

crear la red docker:

docker network create mi-red-personalizada

listar todas las redes docker:

docker network ls

para borrar una red:

docker network rm NOMBRE_O_ID_DE_LA_RED

si Docker no te deja borrar la red y te tira un error diciendo que tiene active endpoints, significa que todavía hay contenedores corriendo que están usando esa red. Primero vas a tener que apagar esos contenedores (docker stop) o desconectarlos de la red a la fuerza con:

docker network disconnect mi-red-personalizada NOMBRE_DEL_CONTENEDOR

Limpieza total (Borrar todas las redes en desuso)

Si estuviste haciendo pruebas y te quedaron un montón de redes flotando que ya ningún contenedor usa, podés borrarlas todas de un solo saque con:

docker network prune

---

debes crear un .jar y luego una imagen docker basada en ese .jar

aquí puedes ver el .jar en /build/libs/

el jar se crea (ubicado en el mismo lugar donde está el script gradlew):

./gradlew bootJar

El nombre de la red solo sirve para que vos le digas a Docker: “Che, meteme estos contenedores adentro de este mismo grupo/isla”

Una vez que los contenedores están adentro de la misma red, el DNS interno de Docker usa el nombre del contenedor (o el nombre del servicio si usás Docker Compose) como si fuera el dominio web

---

ver info de uuna red

 docker network inspect NETWORK-NAME

ejemplo:

 docker network inspect mi-red-personalizada

lo que muestra:

ahí aparecen todos los contenedores docker que estan en esa red

el contenedor docker A llama al contenedor docker B

 "http://backend-container:19999"

la red docker no se usa en absoluto, es solo para indicar cuales contenedores se pueden comunicar entre sí

para llamar al contenedor B desde A primero hay que decirle cual protocolo, http://, y lo invoco con el nombre del contenedor y un puerto

un ejemplo en java springboot:

package com.leibnix.servicetoservice.services;

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

import com.fasterxml.jackson.databind.JsonNode;

@Service
public class AService {

    private RestClient restClient;

    // Al usar el constructor con RestClient.Builder, Spring se encarga de todo de forma nativa
    public AService(RestClient.Builder restClientBuilder) {
        this.restClient = restClientBuilder.baseUrl(BASE_URL).build();
    }

    private final String BASE_URL = "http://backend-container:19999";
    private final String PATH1 = "/api/random-json";
/*
    public AService(RestClient.Builder restClientBuilder) {
        this.restClient = restClientBuilder.baseUrl(BASE_URL).build();
    }
        */

    public String llamarAlServicioB(JsonNode jsonRequest) {

        System.out.println("Received JSON in AService: " + jsonRequest.toString());

    return restClient.post()
            .uri(PATH1)
            .body(jsonRequest)
            .retrieve()
            .body(String.class);
}
}

---

luego se puede hacer un curl a localhost a un contenedor docker que llama a otro:

 curl -X GET localhost:20000/call-backend -H "Content-Type: application/json" -d '{"a":"b"}'

---

la idea es crear una red docker, luego agregar contenedores a esa red asi se comunican, luego de un contenedor llamo a otro contenedor con su protocolo (http://) y el nombre de la red no se usa en absoluto