How to push metric to Opentelemetry with go-sdk

I try to push metric to opentelemetry with go-sdk but I found nothing about doc for it. so far I try with this code but idk what the next step, to be honest, I'm bit confuse with the provider and reader stuff, I'm new in monitoring

    func main() {
	ctx := context.Background()

	res, err := resource.New(ctx, resource.WithAttributes(semconv.ServiceName("my-service")))
	if err != nil {
		panic(err)
	}

	ctx, cancel := context.WithTimeout(ctx, time.Second)
	defer cancel()
	conn, err := grpc.DialContext(ctx, "localhost:4317", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock())
	if err != nil {
		panic(err)
	}

	metricExporter, err := otlpmetricgrpc.New(ctx, otlpmetricgrpc.WithGRPCConn(conn))
	if err != nil {
		panic(err)
	}

	exporter, err := prometheus.New()
	if err != nil {
		panic(err)
	}

	provider := metric.NewMeterProvider(metric.WithReader(exporter))
	meter := provider.Meter("github.com/open-telemetry/opentelemetry-go/example/prometheus")

	counter, err := meter.Float64Counter("foo", instrument.WithDescription("a simple counter"))
	if err != nil {
		panic(err)
	}
	counter.Add(ctx, 5)

	reader := metric.NewPeriodicReader(metricExporter, metric.WithInterval(1*time.Second))

}

the source information i have so far its from here Sample and here Sample

First, it is worth noting that the OTel Go metrics API and SDK are not currently considered stable. I will try to keep my answer focused on higher level items which are included in the stable OpenTelemetry metrics specification so that it doesn't become outdated. Anything go-specific which follows is subject to change.

It looks like you're trying to set up two different types of exporters. The prometheus exporter is scraped by Prometheus, and the otelmetricgrpc exporter creates a connection which pushes metrics over OTLP to a receiver like the OpenTelemetry Collector. You likely only need one and not both of those things. The first sample you linked is actually only for traces, not metrics, but the principal is largely the same.

The entry point for metrics in any OpenTelemetry SDK is a meter provider. The meter provider handles metric related configuration and aggregation and export of data. It is also how users acquire meters. Each code module typically has its own meter. From that meter metrics are created, and from those metrics data points are recorded. All metric points are aggregated together and flow back through the meter provider.

In order to read metrics from a meter provider you need a metric reader of some kind. If you are trying to push metrics using a protocol like OTLP, you would use something like the periodic exporting metric reader which periodically collects metrics from the meter provider and exports them using an exporter.

If you were trying to use a pull-based metric system like prometheus, the exporter acts like the metric reader and reads metrics each time the scrape endpoint is requested by the metric system. This is what is done in the second sample you linked. The serveMetrics function opens a webserver that listens on port 2223 and handles requests to localhost:2223/metrics. Each time a GET request comes in on that endpoint, the metrics are aggregated according to the meter provider configuration and returned in the response body. This allows a system like Prometheus to periodically request metrics from your application.