Menyiapkan API Menggunakan Flask, Cloud SQL Google, dan App Engine

Beberapa kerangka kerja Python dapat digunakan untuk membuat API, dua di antaranya adalah Flask dan Django. Frameworks hadir dengan fungsionalitas yang memudahkan pengembang untuk mengimplementasikan fitur-fitur yang dibutuhkan pengguna untuk berinteraksi dengan aplikasi mereka. Kompleksitas aplikasi web bisa menjadi faktor penentu saat Anda memilih kerangka kerja mana yang akan digunakan.

Django

Django adalah kerangka kerja kuat yang memiliki struktur yang telah ditentukan sebelumnya dengan fungsionalitas bawaan. Kelemahan dari ketangguhannya, bagaimanapun, adalah bahwa hal itu dapat membuat kerangka kerja terlalu rumit untuk proyek-proyek tertentu. Ini paling cocok untuk aplikasi web kompleks yang perlu memanfaatkan fungsionalitas lanjutan Django.

Labu

Flask, di sisi lain, adalah kerangka kerja yang ringan untuk membangun API. Memulainya mudah, dan tersedia paket untuk membuatnya kuat saat Anda menggunakannya. Artikel ini akan fokus pada pendefinisian fungsi tampilan dan pengontrol dan menghubungkan ke database di Google Cloud dan menerapkan ke Google Cloud.

Untuk tujuan pembelajaran, kami akan membangun Flask API dengan beberapa titik akhir untuk mengelola koleksi lagu favorit kami. Titik akhir adalah untuk permintaan GET dan POST : mengambil dan membuat sumber daya. Selain itu, kami akan menggunakan rangkaian layanan di platform Google Cloud. Kami akan menyiapkan Cloud SQL Google untuk database kami dan meluncurkan aplikasi kami dengan menerapkan ke App Engine. Tutorial ini ditujukan untuk pemula yang mencoba pertama kali menggunakan Google Cloud untuk aplikasi mereka.

Menyiapkan Proyek Labu

Tutorial ini mengasumsikan Anda telah menginstal Python 3.x. Jika tidak, kunjungi situs web resmi untuk mengunduh dan menginstalnya.

Untuk memeriksa apakah Python diinstal, luncurkan antarmuka baris perintah (CLI) Anda dan jalankan perintah di bawah ini:

 python -V

Langkah pertama kita adalah membuat direktori tempat proyek kita akan hidup. Kami akan menyebutnya flask-app :

 mkdir flask-app && cd flask-app

Hal pertama yang harus dilakukan ketika memulai proyek Python adalah membuat lingkungan virtual. Lingkungan virtual mengisolasi pengembangan Python Anda yang berfungsi. Ini berarti bahwa proyek ini dapat memiliki ketergantungannya sendiri, berbeda dari proyek lain di mesin Anda. venv adalah modul yang dikirimkan dengan Python 3.

Mari kita buat lingkungan virtual di direktori flask-app kita:

 python3 -m venv env

Perintah ini membuat folder env di direktori kami. Nama (dalam hal ini, env ) adalah alias untuk lingkungan virtual dan dapat diberi nama apa saja.

Sekarang setelah kita membuat lingkungan virtual, kita harus memberi tahu proyek kita untuk menggunakannya. Untuk mengaktifkan lingkungan virtual kami, gunakan perintah berikut:

 source env/bin/activate

Anda akan melihat bahwa prompt CLI Anda sekarang memiliki env di awal, yang menunjukkan bahwa lingkungan kita aktif.

Sekarang, mari kita instal paket Flask kita:

 pip install flask

Buat direktori bernama api di direktori kami saat ini. Kami membuat direktori ini sehingga kami memiliki folder tempat folder lain aplikasi kami akan berada.

 mkdir api && cd api

Selanjutnya, buat file main.py , yang akan berfungsi sebagai titik masuk ke aplikasi kita:

 touch main.py

Buka main.py , dan masukkan kode berikut:

 #main.py from flask import Flask app = Flask(__name__) @app.route('/') def home(): return 'Hello World' if __name__ == '__main__': app.run()

Mari kita pahami apa yang telah kita lakukan di sini. Kami pertama kali mengimpor kelas Flask dari paket Flask. Kemudian, kami membuat instance kelas dan menetapkannya ke app . Selanjutnya, kami membuat titik akhir pertama kami, yang menunjuk ke root aplikasi kami. Singkatnya, ini adalah fungsi tampilan yang memanggil rute / — mengembalikan Hello World .

Mari kita jalankan aplikasinya:

 python main.py

Ini memulai server lokal kami dan melayani aplikasi kami di https://127.0.0.1:5000/ . Masukkan URL di browser Anda, dan Anda akan melihat respons Hello World tercetak di layar Anda.

Dan voila! Aplikasi kami aktif dan berjalan. Tugas selanjutnya adalah membuatnya berfungsi.

Untuk memanggil titik akhir kami, kami akan menggunakan Tukang Pos, yang merupakan layanan yang membantu pengembang menguji titik akhir. Anda dapat mengunduhnya dari situs web resmi.

Mari buat main.py mengembalikan beberapa data:

 #main.py from flask import Flask, jsonify app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) if __name__ == '__main__': app.run()

Di sini, kami menyertakan daftar lagu, termasuk judul lagu dan nama artis. Kami kemudian mengubah root / route menjadi /songs . Rute ini mengembalikan larik lagu yang kami tentukan. Untuk mendapatkan daftar kami sebagai nilai JSON, kami melakukan JSONifikasi daftar dengan meneruskannya melalui jsonify . Sekarang, daripada melihat Hello world yang sederhana, kami melihat daftar artis saat kami mengakses titik akhir https://127.0.0.1:5000/songs .

Anda mungkin telah memperhatikan bahwa setelah setiap perubahan, kami harus me-restart server kami. Untuk mengaktifkan pemuatan ulang otomatis saat kode berubah, mari aktifkan opsi debug. Untuk melakukan ini, ubah app.run menjadi ini:

 app.run(debug=True)

Selanjutnya, mari tambahkan lagu menggunakan permintaan posting ke array kita. Pertama, impor objek request , sehingga kami dapat memproses permintaan yang masuk dari pengguna kami. Kami nanti akan menggunakan objek request dalam fungsi tampilan untuk mendapatkan input pengguna di JSON.

 #main.py from flask import Flask, jsonify, request app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) @app.route('/songs', methods=['POST']) def add_songs(): song = request.get_json() songs.append(song) return jsonify(songs) if __name__ == '__main__': app.run(debug=True)

Fungsi tampilan add_songs kami mengambil lagu yang dikirimkan pengguna dan menambahkannya ke daftar lagu yang ada.

Sejauh ini, kami telah mengembalikan data kami dari daftar Python. Ini hanya percobaan, karena dalam lingkungan yang lebih kuat, data baru kami yang ditambahkan akan hilang jika kami me-restart server. Itu tidak layak, jadi kami akan membutuhkan database langsung untuk menyimpan dan mengambil data. Masuklah Cloud SQL.

Mengapa Menggunakan Instance Cloud SQL?

Menurut situs resmi:

“Google Cloud SQL adalah layanan database terkelola sepenuhnya yang memudahkan penyiapan, pemeliharaan, pengelolaan, dan pengelolaan database MySQL dan PostgreSQL relasional Anda di cloud. Dihosting di Google Cloud Platform, Cloud SQL menyediakan infrastruktur database untuk aplikasi yang berjalan di mana saja.”

Artinya, kami dapat mengalihdayakan pengelolaan infrastruktur basis data sepenuhnya ke Google, dengan harga yang fleksibel.

Perbedaan Antara Cloud SQL Dan Mesin Komputasi Mandiri

Di Google Cloud, kami dapat menjalankan mesin virtual di infrastruktur Compute Engine Google dan menginstal instance SQL kami. Ini berarti kami akan bertanggung jawab atas skalabilitas vertikal, replikasi, dan sejumlah konfigurasi lainnya. Dengan Cloud SQL, kami mendapatkan banyak konfigurasi di luar kotak, sehingga kami dapat menghabiskan lebih banyak waktu untuk kode dan lebih sedikit waktu untuk menyiapkan.

Sebelum kita mulai:

1. Daftar ke Google Cloud. Google menawarkan kredit gratis senilai $300 kepada pengguna baru.
2. Buat proyek. Ini cukup mudah dan dapat dilakukan langsung dari konsol.

Buat Instance Cloud SQL

Setelah mendaftar ke Google Cloud, di panel kiri, gulir ke tab "SQL" dan klik di atasnya.

Pertama, kita diharuskan memilih mesin SQL. Kami akan menggunakan MySQL untuk artikel ini.

Selanjutnya, kita akan membuat sebuah instance. Secara default, instance kami akan dibuat di AS, dan zona akan dipilih secara otomatis untuk kami.

Tetapkan kata sandi root dan beri nama instance, lalu klik tombol "Buat". Anda dapat mengonfigurasi instance lebih lanjut dengan mengeklik tarik-turun "Tampilkan opsi konfigurasi". Pengaturan memungkinkan Anda untuk mengonfigurasi ukuran instans, kapasitas penyimpanan, keamanan, ketersediaan, cadangan, dan banyak lagi. Untuk artikel ini, kita akan menggunakan pengaturan default. Tidak perlu khawatir, variabel-variabel ini dapat diubah nanti.

Mungkin perlu beberapa menit hingga proses selesai. Anda akan tahu bahwa instans sudah siap saat Anda melihat tanda centang hijau. Klik nama instans Anda untuk membuka halaman detail.

Sekarang, setelah kami siap dan berjalan, kami akan melakukan beberapa hal:

1. Buat database.
2. Buat pengguna baru.
3. Daftar putih alamat IP kami.

Buat Basis Data

Arahkan ke tab "Database" untuk membuat database.

Buat Pengguna Baru

Di bagian "Nama host", atur untuk mengizinkan "% (host apa saja)".

Alamat IP daftar putih

Anda dapat terhubung ke instans database Anda dengan salah satu dari dua cara. Alamat IP pribadi memerlukan virtual private cloud (VPC). Jika Anda memilih opsi ini, Google Cloud akan membuat VPC yang dikelola Google dan menempatkan instance Anda di dalamnya. Untuk artikel ini, kami akan menggunakan alamat IP publik , yang merupakan default. Ini bersifat publik dalam arti bahwa hanya orang yang alamat IP-nya telah masuk daftar putih yang dapat mengakses database.

Untuk memasukkan alamat IP Anda ke daftar putih, ketik my ip di pencarian Google untuk mendapatkan IP Anda. Kemudian, buka tab "Koneksi" dan "Tambah Jaringan".

Hubungkan ke Instance

Selanjutnya, navigasikan ke panel “Overview” dan hubungkan menggunakan cloud shell.

Perintah untuk terhubung ke instance Cloud SQL kami akan diketik sebelumnya di konsol.

Anda dapat menggunakan pengguna root atau pengguna yang telah dibuat sebelumnya. Dalam perintah di bawah ini, kami mengatakan: Hubungkan ke instance flask-demo sebagai pengguna USERNAME . Anda akan diminta untuk memasukkan kata sandi pengguna.

 gcloud sql connect flask-demo --user=USERNAME

Jika Anda mendapatkan kesalahan yang mengatakan bahwa Anda tidak memiliki ID proyek, Anda bisa mendapatkan ID proyek Anda dengan menjalankan ini:

 gcloud projects list

Ambil ID proyek yang dihasilkan dari perintah di atas, dan masukkan ke dalam perintah di bawah ini, ganti PROJECT_ID dengan itu.

 gcloud config set project PROJECT_ID

Kemudian, jalankan perintah gcloud sql connect , dan kita akan terhubung.

Jalankan perintah ini untuk melihat database aktif:

 > show databases; 

Database saya bernama db_demo , dan saya akan menjalankan perintah di bawah ini untuk menggunakan database db_demo . Anda mungkin melihat beberapa database lain, seperti information_schema dan performance_schema . Ini ada untuk menyimpan data meta tabel.

 > use db_demo;

Selanjutnya, buat tabel yang mencerminkan daftar dari aplikasi Flask kami. Ketik kode di bawah ini pada notepad dan tempel di cloud shell Anda:

 create table songs( song_id INT NOT NULL AUTO_INCREMENT, title VARCHAR(255), artist VARCHAR(255), genre VARCHAR(255), PRIMARY KEY(song_id) );

Kode ini adalah perintah SQL yang membuat tabel bernama songs , dengan empat kolom ( song_id , title , artist , dan genre ). Kami juga telah menginstruksikan bahwa tabel harus mendefinisikan song_id sebagai kunci utama dan secara otomatis bertambah dari 1.

Sekarang, jalankan show tables; untuk mengkonfirmasi bahwa tabel telah dibuat.

Dan begitu saja, kami telah membuat database dan tabel songs kami.

Tugas kita selanjutnya adalah menyiapkan Google App Engine sehingga kita dapat menerapkan aplikasi kita.

Mesin Aplikasi Google

App Engine adalah platform yang terkelola sepenuhnya untuk mengembangkan dan menghosting aplikasi web dalam skala besar. Keuntungan penerapan ke App Engine adalah memungkinkan aplikasi untuk menskalakan secara otomatis untuk memenuhi lalu lintas masuk.

Situs web App Engine mengatakan:

“Dengan manajemen server nol dan penerapan konfigurasi nol, pengembang hanya dapat fokus membangun aplikasi hebat tanpa biaya manajemen.”

Siapkan Mesin Aplikasi

Ada beberapa cara untuk menyiapkan App Engine: melalui UI Google Cloud Console atau melalui Google Cloud SDK. Kami akan menggunakan SDK untuk bagian ini. Ini memungkinkan kami untuk menerapkan, mengelola, dan memantau instance Google Cloud kami dari mesin lokal kami.

Instal Google Cloud SDK

Ikuti petunjuk untuk mengunduh dan menginstal SDK untuk Mac atau Windows. Panduan ini juga akan menunjukkan cara menginisialisasi SDK di CLI Anda dan cara memilih proyek Google Cloud.

Sekarang SDK telah diinstal, kita akan memperbarui skrip Python dengan kredensial database dan menyebarkannya ke App Engine.

Pengaturan Lokal

Di lingkungan lokal kami, kami akan memperbarui penyiapan agar sesuai dengan arsitektur baru kami, yang mencakup Cloud SQL dan App Engine.

Pertama, tambahkan file app.yaml ke folder root kita. Ini adalah file konfigurasi yang diperlukan App Engine untuk menghosting dan menjalankan aplikasi kami. Ini memberi tahu App Engine tentang runtime kami dan variabel lain yang mungkin diperlukan. Untuk aplikasi kita, kita perlu menambahkan kredensial database kita sebagai variabel lingkungan, sehingga App Engine mengetahui instance database kita.

Di file app.yaml , tambahkan cuplikan di bawah ini. Anda akan mendapatkan variabel runtime dan database dari pengaturan database. Ganti nilai dengan nama pengguna, sandi, nama database, dan nama koneksi yang Anda gunakan saat menyiapkan Cloud SQL.

 #app.yaml runtime: python37 env_variables: CLOUD_SQL_USERNAME: YOUR-DB-USERNAME CLOUD_SQL_PASSWORD: YOUR-DB-PASSWORD CLOUD_SQL_DATABASE_NAME: YOUR-DB-NAME CLOUD_SQL_CONNECTION_NAME: YOUR-CONN-NAME

Sekarang, kita akan menginstal PyMySQL. Ini adalah paket Python MySQL yang menghubungkan dan melakukan query pada database MySQL. Instal paket PyMySQL dengan menjalankan baris ini di CLI Anda:

 pip install pymysql

Pada titik ini, kami siap menggunakan PyMySQL untuk terhubung ke database Cloud SQL kami dari aplikasi. Ini akan memungkinkan kita untuk mendapatkan dan memasukkan kueri ke dalam database kita.

Inisialisasi Konektor Basis Data

Pertama, buat file db.py di folder root kami, dan tambahkan kode di bawah ini:

 #db.py import os import pymysql from flask import jsonify db_user = os.environ.get('CLOUD_SQL_USERNAME') db_password = os.environ.get('CLOUD_SQL_PASSWORD') db_name = os.environ.get('CLOUD_SQL_DATABASE_NAME') db_connection_name = os.environ.get('CLOUD_SQL_CONNECTION_NAME') def open_connection(): unix_socket = '/cloudsql/{}'.format(db_connection_name) try: if os.environ.get('GAE_ENV') == 'standard': conn = pymysql.connect(user=db_user, password=db_password, unix_socket=unix_socket, db=db_name, cursorclass=pymysql.cursors.DictCursor ) except pymysql.MySQLError as e: print(e) return conn def get_songs(): conn = open_connection() with conn.cursor() as cursor: result = cursor.execute('SELECT * FROM songs;') songs = cursor.fetchall() if result > 0: got_songs = jsonify(songs) else: got_songs = 'No Songs in DB' conn.close() return got_songs def add_songs(song): conn = open_connection() with conn.cursor() as cursor: cursor.execute('INSERT INTO songs (title, artist, genre) VALUES(%s, %s, %s)', (song["title"], song["artist"], song["genre"])) conn.commit() conn.close()

Kami melakukan beberapa hal di sini.

Pertama, kami mengambil kredensial database kami dari file app.yaml menggunakan metode os.environ.get . App Engine mampu membuat variabel lingkungan yang didefinisikan di app.yaml tersedia di aplikasi.

Kedua, kami membuat fungsi open_connection . Ini terhubung ke database MySQL kami dengan kredensial.

Ketiga, kami menambahkan dua fungsi: get_songs dan add_songs . Yang pertama memulai koneksi ke database dengan memanggil fungsi open_connection . Kemudian kueri tabel songs untuk setiap baris dan, jika kosong, mengembalikan "Tidak Ada Lagu di DB". Fungsi add_songs menyisipkan rekaman baru ke dalam tabel songs .

Akhirnya, kami kembali ke tempat kami memulai, file main.py kami. Sekarang, alih-alih mendapatkan lagu dari suatu objek, seperti yang kita lakukan sebelumnya, kita memanggil fungsi add_songs untuk menyisipkan record, dan kita memanggil fungsi get_songs untuk mengambil record dari database.

Mari kita refactor main.py :

 #main.py from flask import Flask, jsonify, request from db import get_songs, add_songs app = Flask(__name__) @app.route('/', methods=['POST', 'GET']) def songs(): if request.method == 'POST': if not request.is_json: return jsonify({"msg": "Missing JSON in request"}), 400 add_songs(request.get_json()) return 'Song Added' return get_songs() if __name__ == '__main__': app.run()

Kami mengimpor fungsi get_songs dan add_songs dan memanggilnya dalam fungsi tampilan songs() kami. Jika kita membuat permintaan post , kita memanggil fungsi add_songs , dan jika kita membuat permintaan get , kita memanggil fungsi get_songs .

Dan aplikasi kami selesai.

Selanjutnya adalah menambahkan file requirements.txt . File ini berisi daftar paket yang diperlukan untuk menjalankan aplikasi. App Engine memeriksa file ini dan menginstal paket yang terdaftar.

 pip freeze | grep "Flask\|PyMySQL" > requirements.txt

Baris ini mendapatkan dua paket yang kita gunakan untuk aplikasi (Flask dan PyMySQL), membuat file requirements.txt , dan menambahkan paket dan versinya ke file.

Pada titik ini, kami telah menambahkan tiga file baru: db.py , app.yaml , dan requirements.txt .

Terapkan ke Google App Engine

Jalankan perintah berikut untuk menerapkan aplikasi Anda:

 gcloud app deploy

Jika berjalan dengan baik, konsol Anda akan menampilkan ini:

Aplikasi Anda sekarang berjalan di App Engine. Untuk melihatnya di browser, jalankan gcloud app browse di CLI Anda.

Kami dapat meluncurkan Postman untuk menguji post kami dan get permintaan.

Aplikasi kami sekarang dihosting di infrastruktur Google, dan kami dapat mengubah konfigurasi untuk mendapatkan semua manfaat arsitektur tanpa server. Ke depannya, Anda dapat membangun artikel ini untuk membuat aplikasi tanpa server Anda lebih tangguh.

Kesimpulan

Menggunakan infrastruktur platform-as-a-service (PaaS) seperti App Engine dan Cloud SQL pada dasarnya mengabstraksikan tingkat infrastruktur dan memungkinkan kami membangun lebih cepat. Sebagai pengembang, kita tidak perlu khawatir tentang konfigurasi, pencadangan dan pemulihan, sistem operasi, penskalaan otomatis, firewall, migrasi lalu lintas, dan sebagainya. Namun, jika Anda memerlukan kontrol atas konfigurasi yang mendasarinya, mungkin lebih baik menggunakan layanan yang dibuat khusus.

Referensi

• “Unduh Python”
• “venv — Penciptaan Lingkungan Virtual”, Python (dokumentasi)
• “Unduh Tukang Pos”
• “Cloud SQL”, Google Cloud
• Google Cloud
• “Google Cloud Tingkat Gratis”, Google Cloud
• “Membuat dan Mengelola Proyek”, Google Cloud
• “Ikhtisar VPC” (cloud pribadi virtual), Google Cloud
• “Mesin Aplikasi”, Google Cloud
• “Quickstarts” (unduh Google Cloud SDK), Google Cloud
• Dokumentasi PyMySQL