Microservices - bidirectional communication - microservices

Question

An api-gateway uses a ClientProxy to interact with a microservice (i.e. "service A")
import { ClientProxy } from "#nestjs/microservices"
#Injectable() export class AppService {
constructor(
#Inject("SERVICE_A") private readonly clientServiceA: ClientProxy
) { }
}
The microservice acts like a server, and bootstraps as follows:
async function bootstrap() {
const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.TCP,
options: {
host: "127.0.0.1",
port: 8888
}
});
await app.listen(() => logger.log("Microservice A is listening"));
}
bootstrap();
The API-gateway acts as a client, and uses a ClientsModule to make the connection to "service A". All that is done in the AppModule
import { ClientsModule, Transport } from "#nestjs/microservices";
#Module({
imports: [
ClientsModule.register([
{
name: "SERVICE_A",
transport: Transport.TCP,
options: {
host: "127.0.0.1",
port: 8888
}
}
])
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
I have all this from a great tutorial, which I found here, and I found the same setup in a book (published at Packt).
On a sidenote:
In all honesty, I would expect the API-gateway to also act as a discovery server. Then other microservices would connect to it. That allows multiple instances of each
microservice, and it provides an auto-discovery mechanism.
Microservices only make sense to me if they are loosely coupled. And I
want to migrate to a situation where I can spin up multiple instances
of a microservice and restart individual ones without downtime of the
system. By contrast, the above setup has no real discovery server. There could have been of the microservices connected to the API-gateway. Then the API-gateway would also take the role of a discovery server. But that's clearly not the case. So right now, it's all tightly coupled. That sideinfo may be relevant, but I don't want to overload the question. So, let's not get carried away. Perhaps I am missing something, so I wanted to put this in just as a sidenote.
My real question is, does the above setup allow bi-directional communication. e.g. what if the microservice (service a) wants to make calls to the api-gateway. In other words, is there a ServerProxy ? Or can I use ClientProxy on both ends of the communication ? Or is the only way around that to make 2 connections ?

Answer 1

API gateways are usually designed to control which services/endpoints get exposed to external clients (e.g. SPAs, mobile apps, or customers), and how they should be exposed (e.g. what are the routes, and how should clients authenticate). You should generally avoid putting any business logic into these gateways other than authentication/authorization needed for these external clients to identify themselves.
However, it's not unreasonable to have some of your microservices be dependent on features provided by each other. If you need one microservice to connect to another, you can follow the same pattern you used in the gateway to register the upstream microservice as a client of the downstream service – skipping the gateway altogether for internal service communication. I'd caution you to avoid bi-directional logic between these services as you could quickly lose track of the application flow and create circular references, but it is technically possible to have two microservices be clients of each other.