Why is 2-phase commit not suitable for a microservices architecture?

I've read a post saying that:

We can not implement traditional transaction system like 2 phase commit in micro-services in a distributed environment.

I agree completely with this.

But it would be great if someone here can explain the exact reason for this. What would be the issues I'm going to face if I'm implementing 2-phase commit with microservices?

Thanks in advance

Some things to note and also to give some background:

1. In most scenarios microservices interact via HTTP (a stateless protocol) and as a result global / XA transactions are just not applicable / possible.
2. Exactly once semantics are not possible and you should go for at least once. This means all services should be idempotent.
3. One good example of why is not possible of achieving exactly once semantics in such a setup is that HTTP connections very frequently are lost on the way back to the client. This means that via a POST the state of the server has changed, while the client receives a timeout error.
4. Inside the boundaries of a microservice you can use them just fine. As you mentioned Kafka you can quite easily consume (from 1 topic) and produce (to 1 or more topics) a single atomic / all or nothing operation (exactly once semantics).
5. But if you want global and long running transactions among microservices that interact via HTTP the only practical option (you might see global transaction via HTTP if you Google, but for a production system just ignore them), is to design for eventual consistency. In brief this means, retry for ever for recoverable errors (this is a whole chapter in itself) and expose compensating endpoints or produce compensating events that will eventually amend non-recoverable errors. Check out the Sagas pattern. Narayana Transaction Manager has good Sagas support and a good products comparison.
6. Check out the related microservices patterns that offer an alternative to XA transactions (you might see this as global transactions or 2 phase commit / 2PC) like Transactional Outbox or Event Sourcing that offer nice at least once semantics.
7. Distributed systems are very complicated and you should have a reason to go for such a solution. If you go distributed, operations that your monolith can safely delegate to your transaction manager, will have to be dealt by the developer / architect.
8. Also, the majority of non SQL databases/ systems do not support XA transactions (i.e. global transactions) at all, as they slow down processing dramatically.