Command payload validation in event sourced micro-service architecture
Command handler as a service

I think this is the main source of your confusion.
The command handler isn't normally a service in itself.  It is a pattern.  It will normally be running in the same process as the "microservice" itself.
IE: the command handler reads a message from so storage, and itself invokes the microservice logic that computes how to integrate the information in this message into its own view of the world.

What is actually aggregates

"Aggregate" is a lifecycle management pattern; an aggregate is a graph of one or more domain entities that together will establish and maintain some interesting invariant.  It's one of three patterns described in detail in the Domain Driven Design book written by Eric Evans.
The command handler plus your aggregate is, in a sense, your microservice.  The microservice will typically handle messages for several instances of a single aggregate - it will subscribe to all of the input messages for that kind of aggregate.  The "handler" part just reads the next message, loads the appropriate instance of the aggregate, then executes the domain logic (defined within the aggregate entities) and stores the results.
I am confused about how to realize the data validation in event sourced micro-service architecture.  
Let sum up some aspects that related to the micro-services.
1. Micro-services must be low coupled.
2. Micro-services better to be domain oriented  
Then due to tons of materials in the internet and the books in DDD (Domain Driven Design)
I create the next event sourced micro-service architecture.
Components
1. API getaway to receive the REST calls from the clients and transform them into the commands.
2 Command handler as a service. Receive the commands from API getaway make the validations. Save the events to the event store and publish events to the event bus.
3. Event store is the storage for all events in the system. Allows us to recreate the state of the app. The main state of truth.
4. Micro-services is small services responsible to handle the related to its domain event. Make some projections to the local private databases. Make some events too.
And I have questions that I could not answer both by myself and the internet.
1. What is actually aggregates. They are the class objects/records in databases as I think or what?
2. Who carry about aggregates. I found example that is some cases command handler use them. But in that way if aggregates stored in the private micro-services databases then we will have very high coupling between the command handler and the each of micro-services and it is wrong due to micro-service concept.  
To sum up.
I am confused about how to implement aggregation in event source micro service architecture.
For example let focus on the user registration implementation in event source micro-service architecture.  
We have the user domain so the architecture will be next.
API getaway
Command handler
Auth micro-service
User micro-service 
Please explain me the realization of command validation due to example above.