Publishing to google pub sub asynchronously throug

I'm trying to push the message to google pub-sub asynchronously through goroutine but I'm facing below error panic: not an App Engine context I'm using mux and have an api handler

n = 1 million

    func apihandler(w http.ResponseWriter, r *http.Request) {
       go createuniquecodes(n)
       return "request running in background"
    }

    func createuniquecodes(n) {
       c := make(chan string)
       go createuniquecodes(c, n)  
       for val := range c {        
           publishtopubsub(val)
       } 
   }
   func createuniquecodes(n) {
        for i := 0; i < n; i++ {
           uniquecode := some random string
           // publish to channel and pubsub
           c <- uniquecode
        }
        close(c)
   } 

func publishuq(msg string) error {
   ctx := context.Background()
   client, err := pubsub.NewClient(ctx, projectId)
   if err != nil {
     log.Fatalf("Could not create pubsub Client: %v", err)
   }
   t := client.Topic(topicName)
   result := t.Publish(ctx, &pubsub.Message{
   Data: []byte(msg),
 })
 id, err := result.Get(ctx)
 if err != nil {
    return err
}
fmt.Printf("Published a message; msg ID: %v\n", id)
return nil

}

Please note that I need to generate 5 million unique codes, How will I define a context in go routine since I'm doing everything asynchronously

I assume you're using the App Engine standard (not flexible) environment. Please note that a "request handler (apihandler in your case) has a limited amount of time to generate and return a response to a request, typically around 60 seconds. Once the deadline has been reached, the request handler is interrupted".

You're trying to "break out" of the request when calling go createuniquecodes(n) and then ctx := context.Background() down the line is what panics with not an App Engine context. You could technically use NewContext(req *http.Request) to derive a valid context from the original context, but again, you'd only have 60s before your request times out.

Please have a look at TaskQueues, as they " let applications perform work, called tasks, asynchronously outside of a user request."