Proxy de tráfego ilimitado para recolher dados de treino LLM

    <?php
    $url = "http://myip.lunaproxy.io";
    $proxy = "pr.lunaproxy.com:12233";
    $user = "user-USERNAME";
    $psw = "PASS";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

    curl_setopt($ch, CURLOPT_PROXY, "$proxy");
    curl_setopt($ch, CURLOPT_PROXYUSERPWD, "$user:$psw");
    $result = curl_exec($ch);
    curl_close($ch);

    if ($result)
    {
    echo $result . PHP_EOL;
    }
    ?>
    

    const rp = require( 'request-promise');

    const username = "user-USERNAME";
    const password = "PASS";
    const proxyServer = "pr.lunaproxy.com:12233";

    rp({
    url:'http://myip.lunaproxy.io'
    proxy:`http://${username}:${password}@${proxyServer}`,
    })
    .then(function(data){
    console.log(data);
    })
    .catch(function(data){
    console.log(data);
    })

    import requests

    username = "user-USERNAME"
    password = "PASS"
    proxy_server = "pr.lunaproxy.com:12233"


    proxies = {"http": f"http://{username}:{password}@{proxy_server}"}
    response = requests.get("http://myip.lunaproxy.io", proxies=proxies)
    print(response.text)
    
                    
    

    package main

    import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "net/url"
    )

    const (
    resourceUrl = "http://myip.lunaproxy.io"
    proxyHost   = "pr.lunaproxy.com:12233"
    username    = "user-USERNAME"
    password    = "PASS"
    )

    func main() {
    proxyUrl := &url.URL{
        Scheme: "http",
        User:   url.UserPassword(username, password),
        Host:   proxyHost,
    }

    client := http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyUrl),
        },
    }

    resp, err := client.Get(resourceUrl)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    bodyString := string(body)
    fmt.Println(bodyString)
    }

    import java.io.*;
    import org.apache.http.HttpHost;
    import org.apache.http.auth.*;
    import org.apache.http.client.CredentialsProvider;
    import org.apache.http.client.methods.*;
    import org.apache.http.impl.client.*;
    import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
    import org.apache.http.util.EntityUtils;

    public class JavaHttp {
    public static final String username = "user-USERNAME";
    public static final String password = "PASS";
    public static final int port = 12233;
    public static final String proxyHost = "pr.lunaproxy.com";
    public CloseableHttpClient client;

    public JavaHttp() {
        HttpHost proxy = new HttpHost(proxyHost, port);
        CredentialsProvider cred_provider = new BasicCredentialsProvider();
        cred_provider.setCredentials(new AuthScope(proxy),
                new UsernamePasswordCredentials(username, password));
        client = HttpClients.custom()
                .setConnectionManager(new BasicHttpClientConnectionManager())
                .setProxy(proxy)
                .setDefaultCredentialsProvider(cred_provider)
                .build();
    }

    public String request(String url) throws IOException {
        HttpGet request = new HttpGet(url);
        CloseableHttpResponse response = client.execute(request);
        try {
            return EntityUtils.toString(response.getEntity());
        } finally { response.close(); }
    }

    public void close() throws IOException { client.close(); }

    public static void main(String[] args) throws IOException {
        JavaHttp client = new JavaHttp();
        try {
            System.out.println(client.request("http://myip.lunaproxy.io"));
        } finally { client.close(); }
    }
    }

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Http;
    using System.Text;
    using System.Threading.Tasks;

    class csharp_http
    {
    static void Main(string[] args)
    {
        Task t = new Task(DownloadPageAsync);
        t.Start();
        Console.ReadLine();
    }

    static async void DownloadPageAsync()
    {
        string page = "http://myip.lunaproxy.io";

        var proxy = new WebProxy("pr.lunaproxy.com:12233")
        {
            UseDefaultCredentials = false,

            Credentials = new NetworkCredential(
                userName: "user-USERNAME",
                password: "PASS")
        };

        var httpClientHandler = new HttpClientHandler()
        {
            Proxy = proxy,
        };

        var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);
        var response = await client.GetAsync(page);
        using (HttpContent content = response.Content)
        {
            string result = await content.ReadAsStringAsync();
            Console.WriteLine(result);
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();

        }
    }
    }

    require "uri"
    require 'net/http'

    proxy_host = "pr.lunaproxy.com"
    proxy_port = 12233

    uri = URI.parse('http://myip.lunaproxy.io')
    proxy = Net::HTTP::Proxy(proxy_host, proxy_port)  # No longer use username and password

    req = Net::HTTP::Get.new(uri)

    result = proxy.start(uri.host, uri.port, use_ssl: true) do |http|
    http.request(req)
    end

    puts result.body