How to switch to https on Golang Gin?

Question

I've been looking for a way to switch to https in my Golang server. I thought I found the way already, which involved generating .pem and .key files and passing them as some sort of credentials, but it didn't work. Here's what my current code looks like, I'm also using gRPC btw:

//client side code

package main

import (
    "bytes"
    "encoding/json"
    "flag"
    "fmt"
    "log"
    "sort"
    "strings"

    "github.com/<me>/<repo_name>/cmd/client/handlers"

    "github.com/gin-gonic/gin"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
)

var (
    addr = flag.String("addr", "localhost:50051", "the address to connect to")
)

func main() {
    creds, err := credentials.NewClientTLSFromFile("service.pem", "")

    if err != nil {
        log.Fatalf("could not process the credentials: %v", err)
    }

    flag.Parse()
    conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(creds))

    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }

    defer conn.Close()

    var ginGine = gin.Default()
    StartClient(conn, ginGine)
}

func StartClient(conn *grpc.ClientConn, ginGine *gin.Engine) {

    //some endpoint setup
    handlers.SomethingApiHandler(conn, ginGine)

    // ginGine.RunTLS(":5000", "service.pem", "service.pem")
    ginGine.Run(":5000")
}

//server side code

package main

import (
    "flag"
    "fmt"
    "log"
    "net"

    pb "github.com/<me>/<repo_name>/api/proto/out"
    "github.com/<me>/<repo_name>/cmd/server/handlers"
    "github.com/<me>/<repo_name>/cmd/server/helpers"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
)

func init() {
    helpers.DatabaseConnection()
}

var (
    port = flag.Int("port", 50051, "gRPC server port")
)

func main() {
    creds, err := credentials.NewServerTLSFromFile("service.pem", "service.key")

    if err != nil {
        log.Fatalf("Failed to setup TLS: %v", err)
    }

    flag.Parse()
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    mServ := grpc.NewServer(grpc.Creds(creds))

    fmt.Println("gRPC server running ...")

    //server side endpoint setup

    log.Printf("Server listening at %v", lis.Addr())

    if err := mServ.Serve(lis); err != nil {
        log.Fatalf("failed to serve : %v", err)
    }
}

Using .RunTLS() seemed to have set the client side, which provides the endpoints, to https but it seems like I need to set the server side as well as I got a TLS Handshake error EOF when I called an endpoint using Postman. But I can't find any example for this so I created this question.

UPDATE:

Here's what SomethingAPIHandler looks like:

func NewSomethingClient(cc *grpc.ClientConn) *SomethingClient {
    service := pb.NewSomethingServiceClient(cc)
    return &SomethingClient{service}
}

func SomeApiHandler(cc *grpc.ClientConn, ginGine *gin.Engine) {
    srvClient := NewSomethingClient(cc)

    ginGine.GET("/something/:id", func(ctx *gin.Context) {
        id := ctx.Param("id")

        //auth checking

        res, err := srvClient.service.GetSomething(ctx, &pb.ReadSomethingRequest{Id: id})
        if err != nil {
            ctx.JSON(http.StatusNotFound, gin.H{
                "message": err.Error(),
            })
            return
        }
        ctx.JSON(http.StatusOK, gin.H{
            "something": res.Something,
        })
    })  
}

So I think I'm using gRPC with Gin. I updated the client side code sample above to show the connection of this update to that code.