tomcat deployment golang

Apabila bahasa Go menjadi semakin popular dalam pembangunan web, semakin ramai pembangun mula mempertimbangkan untuk menggunakannya pada pelayan aplikasi Tomcat. Walau bagaimanapun, memandangkan Tomcat sendiri ialah pelayan aplikasi Java dan tidak boleh menyokong penggunaan dan pengendalian bahasa Go secara langsung, kami perlu mencari beberapa kaedah khas untuk mencapai matlamat ini.

Artikel ini akan memperkenalkan beberapa kaedah untuk menggunakan aplikasi bahasa Go dalam Tomcat, bertujuan untuk memberikan rujukan dan panduan untuk pembangun yang mencari penyelesaian sedemikian.

1. Menggunakan Pelayan Caddy

Pelayan Caddy ialah pelayan web sumber terbuka yang menyokong berbilang bahasa dan bahasa pengaturcaraan. Tidak seperti pelayan web lain, salah satu matlamat reka bentuk Pelayan Caddy adalah untuk menyokong bahasa Go, jadi ia boleh digunakan dengan mudah menggunakan Pelayan Caddy dalam Tomcat.

Pertama, kita perlu memuat turun dan memasang Pelayan Caddy. Selepas pemasangan selesai, namakan semula fail kepada app.jar dan letakkannya dalam direktori webapps Tomcat.

Seterusnya, kita perlu menulis Caddyfile untuk mentakrifkan aplikasi kita. Sebagai contoh, jika aplikasi kami mendengar pada port 80 dan memajukan permintaan melalui FastCGI ke aplikasi bahasa Go bernama myapp, kami boleh menulis perkara berikut ke Caddyfile:

myapp {
    proxy / http://localhost:9000 {
        transparent
    }
}

Akhir sekali, kami memerlukan Mulakan Tomcat dan biarkan ia memuatkan Aplikasi Caddy Server. Ini boleh dilakukan dengan arahan berikut:

$ catalina.sh run

Kini kita boleh mengakses aplikasi myapp pada port 80 dan memajukan permintaan ke aplikasi bahasa Go melalui FastCGI.

2. Gunakan perpustakaan FastCGI yang disediakan secara rasmi oleh Go

Bahasa Go menyediakan satu set perpustakaan FastCGI standard yang boleh digunakan oleh pembangun untuk menggunakan aplikasi mereka ke FastCGI Pada pelayan, Aplikasi bahasa Go boleh digunakan dengan mudah menggunakan FastCGI dalam Tomcat.

Pertama, kita perlu memulakan pelayan FastCGI menggunakan perpustakaan FastCGI dalam aplikasi bahasa Go. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "net"
    "net/http"
    "net/http/fcgi"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    listener, err := net.Listen("tcp", "localhost:9000")
    if err != nil {
        panic(err)
    }
    err = fcgi.Serve(listener, http.HandlerFunc(handler))
    if err != nil {
        panic(err)
    }
}

Pada ketika ini, kami mempunyai pelayan asas FastCGI bahasa Go. Seterusnya, kita perlu mengkonfigurasi modul mod_fastcgi Apache dalam Tomcat supaya ia boleh menghantar permintaan kepada aplikasi bahasa Go.

Pertama, kita perlu memasang modul mod_fastcgi. Jika anda menggunakan sistem seperti Ubuntu atau Debian, anda boleh memasangnya menggunakan arahan berikut:

$ sudo apt-get install libapache2-mod-fastcgi

Selepas pemasangan selesai, kami perlu menambah beberapa kandungan pada fail konfigurasi Apache. Berikut ialah contoh mudah:

<IfModule mod_fastcgi.c>
    <Directory /var/www/html/goapp/>
        Options +ExecCGI
        SetHandler fastcgi-script
    </Directory>

    FastCGIExternalServer /var/www/html/goapp/goapp.fcgi -host 127.0.0.1:9000

    <FilesMatch .php$>
        SetHandler application/x-httpd-fastphp
    </FilesMatch>
</IfModule>

Pada ketika ini, kami telah berjaya mengkonfigurasi modul mod_fastcgi. Kini kami boleh menggunakan aplikasi bahasa Go kami ke dalam Tomcat dan membiarkan Apache memajukan permintaan kepadanya.

3. Gunakan perpustakaan net/http yang disediakan secara rasmi oleh Go

Selain pustaka FastCGI, bahasa Go juga menyediakan perpustakaan lain yang mengandungi pelaksanaan pelayan HTTP standard. Kami boleh menggunakan perpustakaan ini untuk memulakan pelayan web dan memajukan permintaan ke aplikasi Go kami.

Pertama, kita perlu menulis pelayan web ringkas dalam aplikasi bahasa Go. Berikut ialah contoh:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    })
    http.ListenAndServe(":9000", nil)
}

Seterusnya, kami perlu mengkonfigurasi modul mod_proxy Apache dalam Tomcat supaya ia boleh memajukan permintaan ke aplikasi bahasa Go kami.

Pertama, kita perlu memasang modul mod_proxy. Jika anda menggunakan sistem seperti Ubuntu atau Debian, anda boleh memasangnya menggunakan arahan berikut:

$ sudo apt-get install libapache2-mod-proxy-html

Selepas pemasangan selesai, kami perlu menambah beberapa kandungan pada fail konfigurasi Apache. Berikut ialah contoh mudah:

<VirtualHost *:*>
    ProxyPreserveHost On

    ProxyPass /goapp http://localhost:9000
    ProxyPassReverse /goapp http://localhost:9000
</VirtualHost>

Pada ketika ini, kami telah berjaya mengkonfigurasi modul mod_proxy. Kini kami boleh menggunakan aplikasi bahasa Go kami ke dalam Tomcat dan memajukan permintaan kepadanya.

Ringkasan

Seperti yang dapat dilihat daripada pengenalan di atas, terdapat banyak kaedah untuk Tomcat menggunakan aplikasi bahasa Go, setiap kaedah mempunyai kelebihan, kelemahan dan senario yang boleh digunakan. Pilih kaedah yang paling sesuai untuk anda dan cuba, dan saya pasti anda akan berjaya mencapai matlamat ini.

Atas ialah kandungan terperinci tomcat deployment golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!