Membina Aplikasi Go dengan Docker pada AWS: Mencipta Antara Muka RESTful untuk Menambah dan Mendapatkan Item

Pengenalan

Walaupun kebanyakan aplikasi Go disusun menjadi satu fail binari, aplikasi web juga disertakan dengan templat, aset dan fail konfigurasi; ini boleh menjadi tidak segerak dan menyebabkan penggunaan yang salah.
Docker membenarkan kami mencipta imej kendiri dengan semua yang diperlukan oleh aplikasi kami untuk dijalankan. Dalam artikel ini, kami akan mempelajari cara untuk menggunakan aplikasi web Go menggunakan Docker yang dipasang pada contoh dan cara Docker boleh membantu anda meningkatkan aliran kerja pembangunan dan proses penggunaan.

Langkah-langkah yang kami perlukan adalah seperti berikut:

- Lancarkan contoh (mesin anda) untuk membina Docker on and the Go
aplikasi
- Pasang Docker contohnya
- Memasang Go dalam contoh
- Buat fail kod untuk aplikasi Go anda
- Ujian Aplikasi

Lancarkan contoh (mesin anda) untuk membina Docker on and the Go
aplikasi

Anda boleh menemui langkah yang sama dalam pelancaran dan penyambungan contoh yang diterangkan dalam artikel:

https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i

Nota: Pastikan anda memilih kumpulan keselamatan:

• SSH-Port 22: Untuk mengakses dan menyambung ke contoh menggunakan SSH
  protokol untuk mengurus sistem dari jauh.

• HTTP-Port 8080: Untuk menjalankan aplikasi Go pada port ini (8080) untuk mengaksesnya daripada Internet atau rangkaian tempatan, port ini mesti dibuka.

- Pasang Docker dalam contoh kami

Seni bina aliran kerja khusus yang akan kami cipta menggunakan Docker untuk menyediakan persekitaran aliran kerja bersepadu.
Jadi selepas menyambung ke contoh melalui SSH dan memperoleh keistimewaan root, gunakan automasi arahan berikut untuk memasang Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - && sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" && sudo apt-get kemas kini && apt- dasar cache docker-ce

Pengalaman Docker: Jalankan arahan ujian mudah docker -v untuk memeriksa sama ada Docker berfungsi dengan betul dan untuk melihat versi Docker:

Memasang Go

Anda boleh memasang Go dengan memuat turunnya daripada tapak web rasmi Go https://go.dev/dl/
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz
echo 'eksport PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile
sumber ~/.bash_profile

di mana :
wget https://golang.org/dl/go1.20.linux-amd64.tar.gz adalah untuk memuat turun binari Go.

dan
sudo tar -C /usr/local -xzf go1.20.linux-amd64.tar.gz adalah untuk mengekstrak bola tar ke /usr/local.
dan
echo 'eksport PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile untuk Kemas kini pembolehubah persekitaran PATH.
dan sumber ~/.bash_profile untuk menggunakan perubahan yang dibuat pada profil

Jadi selepas melaksanakan arahan dan mengesahkan pelaksanaan melalui arahan ls untuk menunjukkan fail yang dimuat turun:

Mulakan aplikasi Go dengan kod berikut:
pergi mod init my-go-app

Sekarang kita perlu mencipta folder projek dengan arahan:
mkdir
Kemudian tukar direktori semasa dengan arahan :
cd
jadi pelaksanaannya ialah :

Buat fail kod untuk aplikasi Go anda

Fail utama.go

Kami mencipta fail baharu yang dipanggil main.go yang mengandungi fungsi dan kod berikut yang akan kami terangkan secara terperinci dan kemudian kami meletakkan semua kod dalam fail main.go:

• Untuk mengimport pakej yang diperlukan kami menggunakan kod:

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• Untuk item struktur data:

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

di mana item ialah struktur data yang mengandungi pengecam (ID) dan nama (Nama). Medan ini ditukar kepada format JSON menggunakan teg (json:"id" dan json:"name".

• pembolehubah item

var items []Item

iaitu kepingan item yang disimpan dalam memori pelayan.

• Melalui fungsi utama, struktur disusun dengan membaca port (di sini ia akan berada pada port 8080) selain mengarahkan pelbagai permintaan daripada mendapatkan semula atau menambah elemen baharu dan memaparkan halaman HTML yang mudah.

import (
    "encoding/json"
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "os"
)

• Fungsi getItems mengembalikan senarai item dalam format JSON. Jenis kandungan dalam pengepala ditetapkan kepada aplikasi/json.

type Item struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

• Fungsi createItem menambah item baharu pada senarai item. Data dibaca daripada Badan Permintaan dalam format JSON, item diberikan ID berdasarkan bilangan item sedia ada dan item yang ditambahkan dikembalikan sebagai JSON.

var items []Item

• Fungsi serveHome memaparkan halaman HTML ringkas dengan mesej alu-aluan (Selamat Datang ke Apl Go) dan pautan untuk mengakses data.

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    router := mux.NewRouter()
    router.HandleFunc("/items", getItems).Methods("GET")
    router.HandleFunc("/items", createItem).Methods("POST")
    router.HandleFunc("/", serveHome).Methods("GET")

    log.Printf("Server is running on port %s...\n", port)
    log.Fatal(http.ListenAndServe(":"+port, router))
}

Jadi keseluruhan fail main.go ialah:

func getItems(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(items)
}

Sekarang melalui arahan vim atau nano buat fail main.go dan letakkan kod di atas dalam fail, di sini kita akan menggunakan arahan nano:

nano main.go

Dan melepasi kod:

kemudian keluar fail dari papan kekunci dengan ctrl x kemudian y (untuk menyimpan fail) kemudian klik masukkan

Fail Docker:

Merupakan dokumen teks yang mengandungi semua arahan yang boleh dipanggil oleh pengguna pada baris arahan untuk memasang imej.
Fail Docker boleh membina imej secara automatik dengan membaca arahan daripada Fail Docker.

Buat fail Docker:

Fail Docker dengan arahan binaan diperlukan untuk membina imej bekas dengan Docker.
Kami mencipta Dockerfile dan menambah kod berikut dengan cara yang sama seperti sebelum ini melalui arahan nano Dockerfile:

Butiran arahan fail Docker boleh didapati di halaman utama dokumen docker https://docs.docker.com/guides/golang/build-images/

Sekarang kami telah menyediakan Dockerfile, tiba masanya untuk membina imej Docker untuk aplikasi Go. Imej itu boleh dibuat daripada imej Docker rasmi iaitu:

docker build -t my-go-app .

Imej berjaya dibina dan untuk memastikan binaan dengan menggunakan arahan:
imej buruh pelabuhan

Kemudian untuk menjalankan bekas selepas membina imej, kami menggunakan:

larian buruh pelabuhan -p 8080:8080 aplikasi saya

di mana 8080 ialah pelabuhan pelayan web, jadi pelaksanaannya ialah:

Ujian Aplikasi

- Uji aplikasi Go dengan arahan curl

Untuk menguji sama ada aplikasi Go berfungsi dengan betul melalui arahan curl dengan:

gulung http://localhost:8080/items

atau

gulung http://:8080/item

perlaksanaan adalah null, yang bermaksud aplikasi berfungsi tetapi kami belum mempunyai data lagi.

Untuk menambah item, dengan arahan:

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://localhost:8080/items

atau

curl -X POST -H "Content-Type: application/json" -d '{"name": "item"}' http://:8080/items

jadi pelaksanaan penambahan:

kita boleh menambah item lain:

- Uji aplikasi Go melalui halaman web

Untuk menguji sama ada aplikasi Go berfungsi dengan betul melalui halaman web, langkah berikut:

• Kembali ke contoh dan pilihnya mengikut kotak pilihan.
• Pergi ke Butiran dan salin alamat IPv4 Awam.
• Tampal alamat IPv4 awam dengan port 8080 ke dalam penyemak imbas dan tekan Masuk.

Halaman web berfungsi dan apabila kami menekan pada item pada halaman kami memperoleh item yang ditambah dengan arahan curl.

Atau boleh tekan kotak pilihan Pretty-print:

Rujukan:

• https://dev.to/zahraajawad/building-a-jupyter-notebook-environment-in-docker-for-data-analysis-on-aws-ec2-376i
• https://semaphoreci.com/community/tutorials/how-to-deploy-a-go-web-application-with-docker
• https://hub.docker.com/_/golang
• https://docs.docker.com/guides/golang/build-images/
• https://github.com/gorilla/mux

Atas ialah kandungan terperinci Membina Aplikasi Go dengan Docker pada AWS: Mencipta Antara Muka RESTful untuk Menambah dan Mendapatkan Item. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!