Go से Kasada हेडर जनरेट करें और लागू करें

Go 1.22 या बाद का संस्करण इस्तेमाल करें और आधिकारिक मॉड्यूल solvethree.com/[email protected] इंस्टॉल करें। इंस्टॉलेशन की जानकारी Go इंटीग्रेशन दस्तावेज़ में है।

स्टैंडअलोन Kasada अभी केवल सटीक होस्टनाम www.ticketmaster.com पर HTTPS लक्ष्यों का समर्थन करता है। उदाहरण उसके होमपेज का अनुरोध करता है; input.URL को उस समर्थित होस्ट पर इच्छित URL में बदलें।

• SOLVETHREE_API_KEY को अपने वर्कस्पेस की API कुंजी पर सेट करें। इसे सर्वर पर रखें।
• SOLVETHREE_PROXY को ऐसे HTTP या HTTPS प्रॉक्सी URL पर सेट करें जिसमें पाथ, क्वेरी या फ़्रैगमेंट न हो। यह उदाहरण एक प्रॉक्सी इस्तेमाल करता है; साथ में ProxyCandidates भी न दें।
• Type को KasadaTask पर ही सेट रखें। Site, Action, RecaptchaType, सेशन या कस्टम ब्राउज़र पहचान के फ़ील्ड न जोड़ें।

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "net/http"
    "net/url"
    "time"
    solvethree "solvethree.com/sdk"
)

func main() {
    client, err := solvethree.NewClient(os.Getenv("SOLVETHREE_API_KEY"), nil)
    if err != nil { log.Fatal(err) }
    ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
    defer cancel()
    input := solvethree.TaskRequest{Type: "KasadaTask", URL: "https://www.ticketmaster.com/", Proxy: os.Getenv("SOLVETHREE_PROXY")}
    result, err := client.Solve(ctx, input, solvethree.SolveOptions{})
    if err != nil { log.Fatal(err) }
    fmt.Println("Ready task:", result.ID)

    proxy, ok := solvethree.SuccessfulProxy(input, result)
    if !ok { log.Fatal("No valid successful proxy") }
    proxyURL, err := url.Parse(proxy)
    if err != nil { log.Fatal(err) }
    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxyURL)
    defer transport.CloseIdleConnections()
    targetClient := &http.Client{Transport: transport, Timeout: 30*time.Second,
        CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
    request, err := http.NewRequestWithContext(ctx, "GET", input.URL, nil)
    if err != nil { log.Fatal(err) }

    request.Header.Set("User-Agent", result.Solution.UserAgent)
    request.Header.Set("sec-ch-ua", result.Solution.SecChUA)
    for name, value := range result.Solution.Headers { request.Header.Set(name, value) }

    response, err := targetClient.Do(request)
    if err != nil { log.Fatal(err) }
    defer response.Body.Close()
    fmt.Println("Application HTTP status:", response.StatusCode)
    // Inspect the application response to determine whether submission succeeded.

}

Kasada के लिए result.Solution.Headers लागू करें, Solution.Token नहीं। लूप लौटाए गए हर हेडर को कॉपी करता है। उससे पहले के असाइनमेंट लौटाए गए UserAgent और SecChUA भी लागू करते हैं; उन्हें अपने ब्राउज़र के मानों से न बदलें।

SuccessfulProxy(input, result) सफल प्रॉक्सी की पहचान करता है और http.ProxyURL लक्ष्य अनुरोध को उसी के ज़रिए भेजता है। सबमिशन के समय दूसरा प्रॉक्सी चुनने के बजाय उसी परिणाम का इस्तेमाल करें। यह तब भी महत्वपूर्ण है जब आप बाद में टास्क को प्रॉक्सी कैंडिडेट इस्तेमाल करने के लिए बदलें।

लक्ष्य अनुरोध input.URL इस्तेमाल करता है, इसलिए सॉल्विंग और सबमिशन एक ही URL को संबोधित करते हैं। रीडायरेक्ट का अनुसरण बंद है: क्लाइंट जनरेट किए गए हेडर को अपने-आप दूसरे URL पर भेजने के बजाय रीडायरेक्ट प्रतिक्रिया लौटाता है।

“तैयार टास्क” का मतलब है कि समाधान जनरेट हो गया है, न कि Ticketmaster ने उसे स्वीकार कर लिया है। उदाहरण एप्लिकेशन का HTTP स्टेटस प्रिंट करता है, लेकिन प्रतिक्रिया की व्याख्या आप पर छोड़ता है। सफलता दर्ज करने से पहले प्रतिक्रिया बॉडी और आपके एप्लिकेशन के अपेक्षित परिणाम की जाँच करें।

टास्क तैयार है, लेकिन लक्ष्य अनुरोध अस्वीकार कर देता है।

भेजे जा रहे अनुरोध की जाँच करें: उसका URL, लौटाया गया हर हेडर, User-Agent, sec-ch-ua और SuccessfulProxy से चुना गया प्रॉक्सी।

यह आज़माएँ: एक और सॉल्व का अनुरोध करने से पहले किसी भी असंगति को ठीक करें। तैयार समाधान आगे की स्वीकृति की गारंटी नहीं देता।

लक्ष्य अनुरोध चलने से पहले Solve त्रुटि लौटाता है।

API की HTTP त्रुटि और टास्क की अंतिम विफलता में अंतर करें। विफल टास्क में errorCode और error शामिल होते हैं।

यह आज़माएँ: अपरिवर्तित अमान्य इनपुट से दोबारा कोशिश करने के बजाय इन विवरणों से अनुरोध ठीक करें। यदि आप Solve की जगह मैन्युअल पोलिंग इस्तेमाल करें, तो टास्क विफल होने पर पोलिंग बंद कर दें।

टास्क बनाने या सॉल्विंग के दौरान होने वाली विफलताओं के लिए API त्रुटि प्रबंधन देखें।