Menyediakan aplikasi Rails baharu dengan Docker & MySQL

Saya seorang jurutera perisian kanan di sebuah syarikat teknologi dan data bersaiz sederhana. Dari segi sejarah, saya telah memakai banyak topi: Saya telah membina aliran pemerolehan pelanggan, melakukan pengurusan pangkalan data, kerja React yang kompleks, mencipta CMS berciri penuh untuk kegunaan dalaman, membina perkhidmatan mikro API Golang yang menghadap awam dari awal, membuat sistem pengesahan API, disampaikan pada pelbagai produk B2B dan B2C, menjadi peneraju teknologi untuk berbilang pasukan (sekaligus), dan banyak lagi. Saya juga pada masa ini agak tidak berlatih apabila membina aplikasi Rails baharu dari awal. Jadi saya fikir saya akan mencubanya!

Ini adalah tutorial yang agak asas tetapi saya telah menemui kekurangan panduan praktikal untuk ini. Walaupun begitu, saya ingin melaungkan dua tutorial yang banyak saya pinjam untuk menulis ini—anggap ini sebagai sintesis siaran tersebut serta beberapa pilihan peribadi saya: Tallan Groberg dan Nícolas Iensen. Kami akan mengelak daripada banyak butiran yang memihak kepada melompat masuk. Saya menulis ini menggunakan M4 Macbook Pro serba baharu tetapi asasnya harus dibawa ke kebanyakan persekitaran Mac atau Linux.

Kami akan membina aplikasi Ruby ringkas yang menggunakan Rails sebagai rangka kerja utama, MySQL untuk pangkalan data (sebahagiannya untuk ciri-cirinya dan sebahagian lagi untuk menambah kerumitan perkara yang saya sasarkan dengan siaran ini), dan Docker untuk virtualisasi dan keserasian merentas platform. Kami tidak membina sebarang model atau pengawal dalam tutorial ini: ini semua tentang persediaan. Menjelang akhir tutorial, anda akan mempunyai apl Hello World yang cukup klasik. Anda sepatutnya boleh mengambil konsep asas ini dan menerapkannya pada mana-mana aplikasi yang anda bina.

Bermula

Perkara pertama dahulu, ini menganggap beberapa kebiasaan dengan terminal dan komputer berasaskan Unix. Jika itu masuk akal, anda perlu memasang Docker dan Homebrew (dengan andaian anda menggunakan Mac). Jika anda menjalankan zsh sebagai shell utama anda (kebanyakan Mac secara lalai hari ini), anda mungkin perlu menambah yang berikut pada fail ~/.zshrc anda untuk dapat menjalankan arahan brew:

path+=/opt/homebrew/bin

Setelah anda menyimpan fail itu, jalankan sumber ~/.zshrc dan anda sepatutnya bagus!

Nota kecil: arahan yang diawali dengan $ menunjukkan arahan yang dijalankan dalam shell tempatan anda (kemungkinan besar zsh atau bash) manakala arahan yang diawali dengan # dijalankan di dalam bekas Docker. Dalam semua kes, awalan tidak boleh disalin, ia hanyalah penunjuk visual gesaan baris baharu.

Perkara pertama dahulu

Ramai pembangun meletakkan semua projek pengekodan mereka ke dalam satu direktori (saya hidup sebagai adik beradik kepada direktori Muat Turun dan Dokumen dan saya secara kreatif memanggilnya sebagai kod). Dalam terminal, navigasi ke direktori setara anda dan taip arahan berikut:

$ mkdir my-app
$ cd my-app

Di dalam direktori baharu ini, kami memerlukan beberapa fail baharu. Cipta mereka dengan arahan berikut:

path+=/opt/homebrew/bin

Yang pertama, Dockerfile.dev akan mencipta imej Docker asas anda, membina imej sedia ada yang memasang versi Ruby yang akan kami gunakan untuk projek ini (yang terkini setakat penulisan ini, 3.3.6) dan menyediakan beberapa butiran kecil tentang bagaimana imej itu harus berkelakuan. Bahagian .dev nama fail menunjukkan bahawa Dockerfile ini hanya akan digunakan secara tempatan dan bukan dalam persekitaran pengeluaran. Perintah yang kami jalankan kemudian dalam tutorial sebenarnya akan membina fail Docker siap pengeluaran yang lebih mantap untuk kami dan saya mahu dapat membezakan keduanya. Memandangkan skop tutorial ini, kami tidak bimbang tentang butiran tersebut. Tambahkan baris berikut pada fail tersebut:

$ mkdir my-app
$ cd my-app

Seterusnya ialah fail docker-compose.yml: tujuannya adalah untuk menyelaraskan beberapa bekas Docker bersama-sama untuk memastikan bahawa aplikasi web yang kami bina mempunyai semua bahagian konstituen bercakap bersama: pelayan web, pangkalan data, berpotensi pelayan Redis, mungkin pelayan Elasticsearch, dsb. Semua elemen berbeza ini akan hidup dalam "komputer maya" mereka sendiri dan perlu disambungkan untuk bercakap antara satu sama lain dengan cara meniru persekitaran pengeluaran. Cukup mengenai perkara teori, perkara penting ialah kita perlu menambah beberapa kod konfigurasi pada fail docker-compose.yml:

$ touch Dockerfile.dev
$ touch docker-compose.yml
$ touch Gemfile

Jangan risau tentang butiran tetapi ia pada dasarnya mengatakan "apabila anda menjalankan ini, anda akan menjalankan aplikasi yang dipanggil 'web' dan ia akan cuba membina aplikasi utama dengan fail docker yang dipanggil 'Dockerfile.dev ' dan akan memetakan port dalaman 3000 dalam rangkaian sistem docker ke port 3000 komputer tempatan yang sedang dijalankan Oh, dan juga, memutarkan pangkalan data dan membenarkan mereka bercakap dengan setiap satu lain." Atau sesuatu seperti itu. Jika anda sudah menjalankan aplikasi pada port 3000, sila tukar nombor port sebelah kiri kepada apa sahaja yang anda suka.

Baiklah! Sekarang kita mempunyai fail yang akan membina imej dan fail lain yang akan menjalankan bekas menggunakan imej itu dan memasukkannya ke dalam rangkaian kecil yang diputarkan. bagus! Tetapi...bagaimana kita melakukannya?

Memasukinya

Untuk mula mengolok-olok, kita perlu masuk ke dalam bekas yang sedang kita bina untuk melakukan beberapa perkara. Kami melakukannya dengan menjalankan ini:

FROM ruby:3.3.6

WORKDIR /usr/src/app

COPY . .
RUN bundle install

Kini kami dalam komputer. Ideanya ialah kini kita boleh menjalankan arahan dalam persekitaran bekas tanpa perlu memasang perisian tertentu pada komputer yang kita gunakan. Rails, sebagai contoh, tidak perlu wujud di mana-mana pada komputer anda untuk dapat menjalankannya pada bekas Docker yang berjalan pada komputer anda. Agak bagus.

Baiklah, sekarang kita sudah masuk, mari pasang Rails:

services:
  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: app
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3307:3306"
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:
      - ".:/usr/src/app"
    ports:
      - "3000:3000"
    depends_on:
      - db
    links:
      - db
    environment:
      DB_USER: root
      DB_NAME: app
      DB_PASSWORD: password
      DB_HOST: db

Dan sekarang mari buat aplikasi kami! Kami ingin membina aplikasi ini menggunakan MySQL, jadi perhatikan spesifikasinya dalam arahan berikut:

path+=/opt/homebrew/bin

Ini akan mengambil sedikit masa. Anda akan ditanya sama ada anda mahu menulis ganti Gemfile. Tekan y untuk mengesahkan. Anda akan ditanya soalan yang sama untuk mana-mana fail lain yang dijana oleh arahan ini. Gunakan kekunci y/n sewajarnya untuk melangkau atau menerima versi baharu.

Huzzah! Kami telah menyelesaikan rangka aplikasi kami! Walau bagaimanapun, kami sebenarnya belum selesai. Kami perlu menangani satu bahagian penting untuk menyediakan pangkalan data. Kemudian, sebaik-baiknya, kita harus menangani butiran keselamatan yang penting.

Menyediakan Pangkalan Data

Bahagian pertama bahagian ini mungkin tidak sangat diperlukan jika anda hanya melakukan sesuatu secara setempat dan tidak merancang untuk menggunakan apa-apa. Selain itu, terdapat banyak lagi yang perlu dipertimbangkan di sini dan saya fikir ia patut mendapat tutorial berasingan untuk menggali beberapa konfigurasi DB dan keselamatan repositori asas—terutamanya jika repositori anda adalah awam (jangan risau jika ya, cuma berhati-hati di luar sana!) .

Dengan arahan sebelumnya, kami mendapat sejumlah besar fail dan direktori baharu. Salah satunya ialah config/database.yml. Bagi saya, pada baris 12 adalah blok yang kelihatan seperti itu:

$ mkdir my-app
$ cd my-app

Secara teknikal perkara di atas berfungsi. Tidak ada yang "salah" dengannya. Tetapi kita boleh melakukan lebih baik. Isu terbesar ialah DB kami tidak mempunyai kata laluan. Isu seterusnya ialah DB tidak mempunyai nama. Akhirnya, nama pengguna boleh dilihat dalam teks biasa. Bukan kegemaran saya. Mari kita ubah semua itu dengan yang berikut (yang pertama daripada yang berikut ialah medan baharu, dua yang kedua harus menggantikan mana-mana nilai sedia ada):

$ touch Dockerfile.dev
$ touch docker-compose.yml
$ touch Gemfile

Anda juga boleh menggunakan gaya ENV.fetch("VARIABLE_NAME") { "fallback_value" }. Perbezaan antara ENV["VARIABLE_NAME"] dan ENV.fetch("VARIABLE_NAME") ialah yang pertama akan mengembalikan sifar jika ia tidak dapat mencari pembolehubah persekitaran dengan nama yang ditetapkan manakala yang terakhir boleh menimbulkan beberapa amaran atau ralat (lihat ini dan ini untuk maklumat lanjut tentang ENV.fetch).

Dengan semua itu, dan dengan mengandaikan anda belum keluar dari shell (anda boleh menggunakan docker-compose run --service-ports web bash untuk masuk semula), kami perlu mencipta pangkalan data baharu. Lakukan itu dengan arahan berikut:

FROM ruby:3.3.6

WORKDIR /usr/src/app

COPY . .
RUN bundle install

Keluar dari shell Docker dan dalam persekitaran terminal tempatan jalankan arahan berikut:

services:
  db:
    image: mysql:5.7
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: app
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3307:3306"
  web:
    build:
      context: .
      dockerfile: Dockerfile.dev
    command: bundle exec rails s -p 3000 -b '0.0.0.0'
    volumes:
      - ".:/usr/src/app"
    ports:
      - "3000:3000"
    depends_on:
      - db
    links:
      - db
    environment:
      DB_USER: root
      DB_NAME: app
      DB_PASSWORD: password
      DB_HOST: db

Itu sahaja! Jika anda menghalakan penyemak imbas anda (atau klien API seperti Postman) di localhost:3000, anda harus melihat halaman permulaan Rails klasik:

Menambah beberapa keselamatan yang sangat mudah

Kami mempunyai aplikasi yang berfungsi! Dan ia didatangkan dengan pangkalan data yang bagus sedia untuk operasi pengeluaran (pangkalan data lalai yang disediakan oleh Rails, SQLite, bagus untuk menggodam idea asas tetapi ia tidak dimaksudkan untuk kerja pengeluaran dan penciptanya adalah pelik)! Tetapi pangkalan data yang lebih mantap disertakan dengan beberapa tanggungjawab tambahan.

Seperti yang kita lihat sebelum ini dalam tutorial ini, kami ditugaskan untuk menyediakan tiga nilai penting: nama pangkalan data, nama pengguna dan kata laluan untuk pengguna tersebut. Setakat ini, kami mempunyai 1 lapisan abstraksi: daripada hanya menghantar nilai rentetan mentah ke database.yml, kami mengambil nilai tersebut daripada persekitaran Rails. Jadi, di manakah persekitaran Rails mendapat nilai tersebut? Daripada fail docker-compose.yml!

Tetapi ia meninggalkan masalah penting yang masih perlu diselesaikan: dengan mengandaikan kami akan menggunakan kod ini dalam pengeluaran, kami telah menyertakan maklumat bahawa tiada sesiapa kecuali pentadbir sistem harus mempunyai akses ke kanan dalam kod itu sendiri. Itu tidak hebat. Kita harus mempunyai lapisan abstraksi tambahan yang mengalih keluar sebarang rujukan langsung kepada maklumat berharga tertentu yang secara teorinya terdiri daripada maklumat.

Sekarang, kita perlu benar-benar DAPATKAN pembolehubah persekitaran tersebut ditetapkan dengan betul dalam persekitaran Ruby kita apabila ia mula-mula berputar. Kami akan melakukan ini dalam dua langkah, tetapi jangan ragu untuk melakukannya dalam satu langkah jika anda selesa. Mula-mula kita perlu berhenti merujuk terus kepada rahsia DB dalam projek Rails. Kami sedang melakukan itu. Seterusnya kita perlu menyalurkannya dari Docker ke Rails. Akhir sekali, kami akan mengabstrakkannya dengan lebih jauh lagi dengan menambahkan nilai rahsia daripada fail yang kami sembunyikan daripada Git untuk mengaburkan maklumat ini dengan lebih baik daripada kemungkinan ne'er-do-wells.

Pembolehubah persekitaran paip ke dalam Rails dari Docker

Kami mempunyai beberapa pilihan, tetapi matlamat saya ialah mencipta fail persekitaran tempat nilai ini disimpan. Jika anda bekerja dengan pasukan, anda boleh berkongsi fail ini antara anda melalui langkah yang lebih tersembunyi (penyulitan GPG adalah klasik) tanpa mengambil risiko meletakkan maklumat ini di internet awam. Jika anda melihat pada fail .gitignore yang mungkin dibuat semasa anda menjalankan rails baru beberapa ketika dahulu, anda akan dapati terdapat item baris untuk mana-mana fail dalam akar projek yang bermula dengan .env. Itulah yang kami mahukan: fail rahsia yang tidak ditambahkan pada penjejakan git tetapi tempat kami boleh menyimpan maklumat penting dan rahsia teratas dalam teks biasa. Jom buat:

path+=/opt/homebrew/bin

Saya menambah akhiran .dev sekiranya kita akhirnya mahukan fail persekitaran yang berbeza untuk pembangunan, pengeluaran dan persekitaran ujian. Dalam fail yang baru dibuat itu, mari tambahkan beberapa nilai:

$ mkdir my-app
$ cd my-app

Kami juga perlu mengemas kini fail docker-compose.yml untuk benar-benar menggunakan fail persekitaran baharu. Di bawah perkhidmatan web, tambahkan yang berikut:

$ touch Dockerfile.dev
$ touch docker-compose.yml
$ touch Gemfile

Dan itu sahaja! Mulakan aplikasi sekali lagi dengan docker compose dan navigasi ke localhost:3000 untuk mengesahkan bahawa semuanya baik-baik saja.

Atas ialah kandungan terperinci Menyediakan aplikasi Rails baharu dengan Docker & MySQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!