പൈത്തണിൽ ഒരു API എഴുതുന്നു (Flask ഉം RapidAPI ഉം)

നിങ്ങൾ ഈ ലേഖനം വായിക്കുന്നുണ്ടെങ്കിൽ, ഒരു API (അപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ്) ഉപയോഗിച്ച് വരുന്ന സാധ്യതകൾ നിങ്ങൾക്ക് ഇതിനകം പരിചിതമായിരിക്കും.

നിങ്ങളുടെ ആപ്ലിക്കേഷനിലേക്ക് നിരവധി ഓപ്പൺ API-കളിൽ ഒന്ന് ചേർക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ആപ്ലിക്കേഷന്റെ പ്രവർത്തനം വിപുലീകരിക്കാം അല്ലെങ്കിൽ ആവശ്യമായ ഡാറ്റ ഉപയോഗിച്ച് സമ്പന്നമാക്കാം. എന്നാൽ കമ്മ്യൂണിറ്റിയുമായി പങ്കിടാൻ ആഗ്രഹിക്കുന്ന ഒരു അദ്വിതീയ സവിശേഷത നിങ്ങൾ വികസിപ്പിച്ചാലോ?

ഉത്തരം ലളിതമാണ്: നിങ്ങൾക്ക് ആവശ്യമാണ് നിങ്ങളുടെ സ്വന്തം API സൃഷ്ടിക്കുക.

ഇത് ആദ്യം ബുദ്ധിമുട്ടുള്ള കാര്യമാണെന്ന് തോന്നുമെങ്കിലും, ഇത് യഥാർത്ഥത്തിൽ ലളിതമാണ്. പൈത്തൺ ഉപയോഗിച്ച് ഇത് എങ്ങനെ ചെയ്യാമെന്ന് ഞങ്ങൾ കാണിച്ചുതരാം.

നിങ്ങൾ ആരംഭിക്കേണ്ടത് എന്താണ്

ഒരു API വികസിപ്പിക്കുന്നതിന് നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

• പൈത്തൺ 3;
• ഫ്ലാസ്ക് - വെബ് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ലളിതവും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമായ ചട്ടക്കൂട്;
• ഫ്ലാസ്ക്-വിശ്രമം വേഗത്തിലും കുറഞ്ഞ കോൺഫിഗറേഷനിലും ഒരു REST API വികസിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന Flask-നുള്ള ഒരു വിപുലീകരണമാണ്.

കമാൻഡ് ഉപയോഗിച്ചാണ് ഇൻസ്റ്റാളേഷൻ നടത്തുന്നത്:

pip install flask-restful

തുടക്കക്കാർക്കായി ഒരു സൗജന്യ തീവ്ര പ്രോഗ്രാമിംഗ് കോഴ്സ് ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു:
C#-ലെ ടെലിഗ്രാം ബോട്ട് വികസനം - ഓഗസ്റ്റ് 26-28. അസിസ്റ്റന്റ് ബോട്ടുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു, ടെലിഗ്രാം API-യിൽ പ്രവർത്തിക്കുന്നതിന്റെ പ്രത്യേകതകൾ, മറ്റ് സൂക്ഷ്മതകൾ എന്നിവ മനസ്സിലാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സൗജന്യ തീവ്രമായ കോഴ്സ്. മൂന്ന് മികച്ച പങ്കാളികൾക്ക് സ്കിൽബോക്സിൽ നിന്ന് 30 റൂബിൾസ് ലഭിക്കും.

നിങ്ങൾ തുടങ്ങുന്നതിനു മുമ്പ്

ഞങ്ങൾ അടിസ്ഥാനപരമായ ഒരു RESTful API വികസിപ്പിക്കാൻ പോകുന്നു CRUID പ്രവർത്തനം.

ചുമതല പൂർണ്ണമായി മനസ്സിലാക്കാൻ, മുകളിൽ സൂചിപ്പിച്ച രണ്ട് പദങ്ങൾ നമുക്ക് മനസ്സിലാക്കാം.

എന്താണ് REST?

ഡാറ്റ കൈമാറ്റം ചെയ്യുന്നതിന് HTTP അഭ്യർത്ഥനകൾ ഉപയോഗിക്കുന്ന ഒരു API ആണ് REST API (പ്രാതിനിധ്യ സ്റ്റേറ്റ് ട്രാൻസ്ഫർ).

REST API-കൾ ചില മാനദണ്ഡങ്ങൾ പാലിക്കണം:

• ക്ലയന്റ്-സെർവർ ആർക്കിടെക്ചർ: ക്ലയന്റ് ഉപയോക്തൃ ഇന്റർഫേസുമായി സംവദിക്കുന്നു, കൂടാതെ സെർവർ ബാക്കെൻഡുമായും ഡാറ്റ സംഭരണവുമായും സംവദിക്കുന്നു. ക്ലയന്റും സെർവറും സ്വതന്ത്രമാണ്, അവയിലേതെങ്കിലും മറ്റൊന്നിൽ നിന്ന് പ്രത്യേകം മാറ്റിസ്ഥാപിക്കാം.
• സ്‌റ്റേറ്റ്‌ലെസ്സ് - ക്ലയന്റ് ഡാറ്റയൊന്നും സെർവറിൽ സംഭരിച്ചിട്ടില്ല. സെഷൻ നില ക്ലയന്റ് വശത്ത് സംഭരിച്ചിരിക്കുന്നു.
• കാഷെബിലിറ്റി - മൊത്തത്തിലുള്ള പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് ക്ലയന്റുകൾക്ക് സെർവർ പ്രതികരണങ്ങൾ കാഷെ ചെയ്യാൻ കഴിയും.

എന്താണ് CRUD?

ക്രൂഡ് നാല് അടിസ്ഥാന പ്രവർത്തനങ്ങൾ വിവരിക്കുന്ന ഒരു പ്രോഗ്രാമിംഗ് ആശയമാണ് (സൃഷ്ടിക്കുക, വായിക്കുക, അപ്ഡേറ്റ് ചെയ്യുക, ഇല്ലാതാക്കുക).

REST API-ൽ, പോസ്റ്റ്, നേടുക, ഇടുക, ഇല്ലാതാക്കുക തുടങ്ങിയ പ്രവർത്തനങ്ങൾക്ക് അഭ്യർത്ഥന തരങ്ങളും അഭ്യർത്ഥന രീതികളും ഉത്തരവാദികളാണ്.

ഇപ്പോൾ ഞങ്ങൾ അടിസ്ഥാന നിബന്ധനകൾ മനസ്സിലാക്കുന്നു, നമുക്ക് API സൃഷ്ടിക്കാൻ തുടങ്ങാം.

വികസനം

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസിനെക്കുറിച്ചുള്ള ഉദ്ധരണികളുടെ ഒരു ശേഖരം നമുക്ക് സൃഷ്ടിക്കാം. ഇന്ന് അതിവേഗം വളരുന്ന സാങ്കേതിക വിദ്യകളിൽ ഒന്നാണ് AI, AI-യുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു ജനപ്രിയ ഉപകരണമാണ് പൈത്തൺ.

ഈ API ഉപയോഗിച്ച്, ഒരു പൈത്തൺ ഡെവലപ്പർക്ക് AI-യെക്കുറിച്ചുള്ള വിവരങ്ങൾ വേഗത്തിൽ നേടാനും പുതിയ മുന്നേറ്റങ്ങളിൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ട് പ്രവർത്തിക്കാനും കഴിയും. ഒരു ഡെവലപ്പർക്ക് ഈ വിഷയത്തിൽ മൂല്യവത്തായ ചിന്തകൾ ഉണ്ടെങ്കിൽ, അവ ശേഖരത്തിലേക്ക് ചേർക്കാൻ അദ്ദേഹത്തിന് കഴിയും.

ആവശ്യമായ മൊഡ്യൂളുകൾ ഇറക്കുമതി ചെയ്ത് ഫ്ലാസ്ക് സജ്ജീകരിച്ചുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം:

from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)

ഈ സ്‌നിപ്പെറ്റിൽ, ഫ്ലാസ്ക്, എപി, റിസോഴ്സ് എന്നിവയാണ് നമുക്ക് ആവശ്യമായ ക്ലാസുകൾ.

Reqparse ഒരു Flask-RESTful ക്വറി പാഴ്‌സിംഗ് ഇന്റർഫേസാണ്... ക്രമരഹിതമായ ഉദ്ധരണി പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു റാൻഡം മൊഡ്യൂളും ആവശ്യമാണ്.

ഇപ്പോൾ ഞങ്ങൾ AI-യെക്കുറിച്ചുള്ള ഉദ്ധരണികളുടെ ഒരു ശേഖരം സൃഷ്ടിക്കും.

ഓരോ റിപ്പോ എൻട്രിയിലും അടങ്ങിയിരിക്കും:

• ഡിജിറ്റൽ ഐഡി;
• ഉദ്ധരണിയുടെ രചയിതാവിന്റെ പേര്;
• ഉദ്ധരണി.

ഇതൊരു പരിശീലന ഉദാഹരണം മാത്രമായതിനാൽ, ഞങ്ങൾ എല്ലാ എൻട്രികളും ഒരു പൈത്തൺ ലിസ്റ്റിൽ സംഭരിക്കും. ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ, പകരം ഞങ്ങൾ ഒരു ഡാറ്റാബേസ് ഉപയോഗിക്കും.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "The business plans of the next 10,000 startups are easy to forecast: " +
                 "Take X and add AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "The development of full artificial intelligence could " +
                 "spell the end of the human race… " +
                 "It would take off on its own, and re-design " +
                 "itself at an ever increasing rate. " +
                 "Humans, who are limited by slow biological evolution, " +
                 "couldn't compete, and would be superseded."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "I visualize a time when we will be to robots what " +
                 "dogs are to humans, " +
                 "and I’m rooting for the machines."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "The pace of progress in artificial intelligence " +
                 "(I’m not referring to narrow AI) " +
                 "is incredibly fast. Unless you have direct " +
                 "exposure to groups like Deepmind, " +
                 "you have no idea how fast — it is growing " +
                 "at a pace close to exponential. " +
                 "The risk of something seriously dangerous " +
                 "happening is in the five-year timeframe." +
                 "10 years at most."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "I have always been convinced that the only way " +
                 "to get artificial intelligence to work " +
                 "is to do the computation in a way similar to the human brain. " +
                 "That is the goal I have been pursuing. We are making progress, " +
                 "though we still have lots to learn about " +
                 "how the brain actually works."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "People worry that computers will " +
                 "get too smart and take over the world, " +
                 "but the real problem is that they're too stupid " +
                 "and they've already taken over the world."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "It seems probable that once the machine thinking " +
                 "method had started, it would not take long " +
                 "to outstrip our feeble powers… " +
                 "They would be able to converse " +
                 "with each other to sharpen their wits. " +
                 "At some stage therefore, we should " +
                 "have to expect the machines to take control."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Artificial intelligence will reach " +
                 "human levels by around 2029. " +
                 "Follow that out further to, say, 2045, " +
                 "we will have multiplied the intelligence, " +
                 "the human biological machine intelligence " +
                 "of our civilization a billion-fold."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nobody phrases it this way, but I think " +
                 "that artificial intelligence " +
                 "is almost a humanities discipline. It's really an attempt " +
                 "to understand human intelligence and human cognition."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "We're making this analogy that AI is the new electricity." +
                 "Electricity transformed industries: agriculture, " +
                 "transportation, communication, manufacturing."
    }
]

ഞങ്ങളുടെ API എൻഡ്‌പോയിന്റുകളുടെ പ്രവർത്തനങ്ങളെ നിർവചിക്കുന്ന ഒരു ഉദ്ധരണി റിസോഴ്‌സ് ക്ലാസ് സൃഷ്‌ടിക്കേണ്ടതുണ്ട്. ക്ലാസിനുള്ളിൽ നിങ്ങൾ നാല് രീതികൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട്: നേടുക, പോസ്റ്റ് ചെയ്യുക, ഇടുക, ഇല്ലാതാക്കുക.

നമുക്ക് GET രീതി ഉപയോഗിച്ച് ആരംഭിക്കാം

ഒരു നിർദ്ദിഷ്ട ഉദ്ധരണി അതിന്റെ ഐഡി വ്യക്തമാക്കുന്നതിലൂടെ അല്ലെങ്കിൽ ഐഡി വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ ക്രമരഹിതമായ ഉദ്ധരണി നേടുന്നത് സാധ്യമാക്കുന്നു.

class Quote(Resource):
    def get(self, id=0):
        if id == 0:
            return random.choice(ai_quotes), 200
        for quote in ai_quotes:
            if(quote["id"] == id):
                return quote, 200
        return "Quote not found", 404

ഐഡിയിൽ ഡിഫോൾട്ട് മൂല്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, GET രീതി ക്രമരഹിതമായ ഒരു ഉദ്ധരണി നൽകുന്നു, അതായത്. രീതി വിളിക്കുമ്പോൾ ഐഡി ഒന്നും വ്യക്തമാക്കിയിട്ടില്ല.

ഇത് വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, രീതി അവലംബങ്ങൾക്കിടയിൽ തിരയുകയും നിർദ്ദിഷ്ട ഐഡി അടങ്ങിയിരിക്കുന്ന ഒന്ന് കണ്ടെത്തുകയും ചെയ്യുന്നു. ഒന്നും കണ്ടെത്തിയില്ലെങ്കിൽ, "ഉദ്ധരണി കണ്ടെത്തിയില്ല, 404" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും.

ഓർമ്മിക്കുക: അഭ്യർത്ഥന വിജയിച്ചാൽ 200 എന്ന HTTP സ്റ്റാറ്റസും റെക്കോർഡ് കണ്ടെത്തിയില്ലെങ്കിൽ 404 ഉം രീതി നൽകുന്നു.

റിപ്പോസിറ്ററിയിലേക്ക് ഒരു പുതിയ ഉദ്ധരണി ചേർക്കുന്നതിന് ഇപ്പോൾ നമുക്ക് ഒരു POST രീതി സൃഷ്ടിക്കാം

നിങ്ങൾ ടൈപ്പ് ചെയ്യുമ്പോൾ ഓരോ പുതിയ ഉദ്ധരണിയുടെയും ഐഡി ഇതിന് ലഭിക്കും. കൂടാതെ, അഭ്യർത്ഥന ബോഡിയിൽ (രചയിതാവും ഉദ്ധരണി വാചകവും) പോകുന്ന പാരാമീറ്ററുകൾ പാഴ്‌സ് ചെയ്യാൻ POST reqparse ഉപയോഗിക്കും.

def post(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              return f"Quote with id {id} already exists", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

മുകളിലെ കോഡിൽ, POST രീതി ഉദ്ധരണി ഐഡി അംഗീകരിച്ചു. തുടർന്ന്, reqparse ഉപയോഗിച്ച്, അത് ചോദ്യത്തിൽ നിന്ന് രചയിതാവിനെയും അവലംബത്തെയും വീണ്ടെടുത്തു, അവ പാരാംസ് നിഘണ്ടുവിൽ സംഭരിച്ചു.

നിർദ്ദിഷ്‌ട ഐഡിയുള്ള ഒരു ഉദ്ധരണി നിലവിലുണ്ടെങ്കിൽ, രീതി അനുബന്ധ സന്ദേശവും 400 കോഡും പ്രദർശിപ്പിക്കുന്നു.

നിർദ്ദിഷ്ട ഐഡിയുള്ള ഒരു അവലംബം ഇതുവരെ സൃഷ്ടിച്ചിട്ടില്ലെങ്കിൽ, നിർദ്ദിഷ്ട ഐഡിയും രചയിതാവും മറ്റ് പാരാമീറ്ററുകളും ഉപയോഗിച്ച് രീതി ഒരു പുതിയ റെക്കോർഡ് സൃഷ്ടിക്കുന്നു. ഇത് പിന്നീട് ai_quotes ലിസ്റ്റിലേക്ക് എൻട്രി ചേർക്കുകയും ഒരു 201 കോഡിനൊപ്പം പുതിയ ഉദ്ധരണിക്കൊപ്പം എൻട്രി നൽകുകയും ചെയ്യുന്നു.

റിപ്പോസിറ്ററിയിൽ നിലവിലുള്ള ഒരു ഉദ്ധരണി മാറ്റാൻ ഞങ്ങൾ ഇപ്പോൾ ഒരു PUT രീതി സൃഷ്ടിക്കുന്നു

def put(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              quote["author"] = params["author"]
              quote["quote"] = params["quote"]
              return quote, 200
      
      quote = {
          "id": id,
          "author": params["author"],
          "quote": params["quote"]
      }
      
      ai_quotes.append(quote)
      return quote, 201

മുമ്പത്തെ ഉദാഹരണത്തിന് സമാനമായ PUT രീതി, ഐഡിയും ഇൻപുട്ടും എടുക്കുകയും reqparse ഉപയോഗിച്ച് ഉദ്ധരണി പാരാമീറ്ററുകൾ പാഴ്‌സ് ചെയ്യുകയും ചെയ്യുന്നു.

നിർദ്ദിഷ്‌ട ഐഡിയുള്ള ഒരു ഉദ്ധരണി നിലവിലുണ്ടെങ്കിൽ, രീതി അത് പുതിയ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്യും, തുടർന്ന് കോഡ് 200 ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്‌ത അവലംബം ഔട്ട്‌പുട്ട് ചെയ്യും. നിർദ്ദിഷ്‌ട ഐഡിയിൽ ഇതുവരെ അവലംബമൊന്നും ഇല്ലെങ്കിൽ, കോഡ് 201 ഉള്ള ഒരു പുതിയ റെക്കോർഡ് സൃഷ്‌ടിക്കും.

അവസാനമായി, ഇനി പ്രചോദിപ്പിക്കാത്ത ഒരു ഉദ്ധരണി നീക്കം ചെയ്യാൻ നമുക്ക് ഒരു DELETE രീതി സൃഷ്ടിക്കാം

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Quote with id {id} is deleted.", 200

ഈ രീതിക്ക് ഉദ്ധരണി ഐഡി ഇൻപുട്ടായി ലഭിക്കുകയും പങ്കിട്ട ലിസ്റ്റ് ഉപയോഗിച്ച് ai_quotes ലിസ്റ്റ് അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.

ഇപ്പോൾ ഞങ്ങൾ എല്ലാ രീതികളും സൃഷ്ടിച്ചു, ഞങ്ങൾ ചെയ്യേണ്ടത് API-യിലേക്ക് ഒരു റിസോഴ്സ് ചേർക്കുകയും പാത സജ്ജമാക്കുകയും ഫ്ലാസ്ക് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക.

api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
    app.run(debug=True)

ഞങ്ങളുടെ REST API സേവനം തയ്യാറാണ്!

അടുത്തതായി, കമാൻഡ് ഉപയോഗിച്ച് കൺസോളിൽ പ്രവർത്തിപ്പിച്ച് നമുക്ക് app.py ഫയലിലേക്ക് കോഡ് സംരക്ഷിക്കാൻ കഴിയും:

python3 app.py

എല്ലാം നല്ലതാണെങ്കിൽ, ഞങ്ങൾക്ക് ഇതുപോലൊന്ന് ലഭിക്കും:

* ഡീബഗ് മോഡ്: ഓൺ
*ഓടുന്നു 127.0.0.1:5000/ (പുറത്തിറങ്ങാൻ CTRL+C അമർത്തുക)
* സ്റ്റാറ്റ് ഉപയോഗിച്ച് പുനരാരംഭിക്കുന്നു
* ഡീബഗ്ഗർ സജീവമാണ്!
* ഡീബഗ്ഗർ പിൻ: XXXXXXX

API പരിശോധിക്കുന്നു

API സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, അത് പരീക്ഷിക്കേണ്ടതുണ്ട്.

ഇത് curl കൺസോൾ യൂട്ടിലിറ്റി അല്ലെങ്കിൽ ഇൻസോമ്നിയ REST ക്ലയന്റ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ റാപ്പിഡ് API-യിൽ API പ്രസിദ്ധീകരിക്കുന്നതിലൂടെയോ ചെയ്യാം.

ഞങ്ങളുടെ API പ്രസിദ്ധീകരിക്കുന്നു

10-ലധികം API-കൾ (ഏകദേശം 000 ദശലക്ഷം ഡെവലപ്പർമാരും) ഉള്ള ലോകത്തിലെ ഏറ്റവും വലിയ വിപണിയാണ് RapidAPI.

RapidAPI മൂന്നാം കക്ഷി API-കളിൽ പ്രവർത്തിക്കുന്നതിന് ഒരൊറ്റ ഇന്റർഫേസ് മാത്രമല്ല, നിങ്ങളുടെ സ്വന്തം API വേഗത്തിലും എളുപ്പത്തിലും പ്രസിദ്ധീകരിക്കാനുള്ള കഴിവും നൽകുന്നു.

ചെയ്യുന്നതിന് ചെയ്യു, നിങ്ങൾ ആദ്യം അത് നെറ്റ്‌വർക്കിലെ ഏതെങ്കിലും സെർവറിൽ പ്രസിദ്ധീകരിക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ കാര്യത്തിൽ ഞങ്ങൾ ഉപയോഗിക്കും ഹെറോക്കു. ഇത് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ബുദ്ധിമുട്ടുകൾ ഉണ്ടാക്കരുത്, (നിങ്ങൾക്ക് അവനെക്കുറിച്ച് കൂടുതൽ ഇവിടെ കണ്ടെത്താനാകും).

Heroku-ൽ നിങ്ങളുടെ API എങ്ങനെ പ്രസിദ്ധീകരിക്കാം

1. Heroku ഇൻസ്റ്റാൾ ചെയ്യുക.

Heroku കമാൻഡ് ലൈൻ ഇന്റർഫേസ് (CLI) രജിസ്റ്റർ ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യുക എന്നതാണ് ആദ്യപടി. ഇത് ഉബുണ്ടു 16+ ൽ പ്രവർത്തിക്കുന്നു.

സുഡോ സ്നാപ്പ് ഇൻസ്റ്റാൾ ഹീറോകു —ക്ലാസിക്

തുടർന്ന് ലോഗിൻ ചെയ്യുക:

ഹീറോകു ലോഗിൻ

2. ആവശ്യമായ ഫയലുകൾ ചേർക്കുക.

ഇപ്പോൾ പ്രസിദ്ധീകരിക്കേണ്ട ഫയലുകൾ ഞങ്ങളുടെ ആപ്ലിക്കേഷനിലെ ഒരു ഫോൾഡറിലേക്ക് ചേർക്കേണ്ടതുണ്ട്:

• ആവശ്യമുള്ള പൈത്തൺ മൊഡ്യൂളുകളുടെ ഒരു ലിസ്‌റ്റ് ഉള്ള ആവശ്യകതകൾ.txt;
• ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് എന്ത് കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് വ്യക്തമാക്കുന്ന Procfile;
• .gitignore - സെർവറിൽ ആവശ്യമില്ലാത്ത ഫയലുകൾ ഒഴിവാക്കാൻ.

ആവശ്യകതകൾ.txt ഫയലിൽ ഇനിപ്പറയുന്ന വരികൾ അടങ്ങിയിരിക്കും:

• ഫ്ലാസ്ക്
• ഫ്ലാസ്ക്-വിശ്രമം
• ഗുനികോൺ

ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സെർവറിൽ പ്രവർത്തിപ്പിക്കേണ്ടതിനാൽ ഞങ്ങൾ ഗണികോൺ (പൈത്തൺ WSGI HTTP സെർവർ) പട്ടികയിൽ ചേർത്തുവെന്നത് ശ്രദ്ധിക്കുക.

പ്രൊഫൈലിൽ അടങ്ങിയിരിക്കും:

web: gunicorn app:app

.gitignore-ന്റെ ഉള്ളടക്കം:

*.pyc
__pycache__/

ഇപ്പോൾ ഫയലുകൾ സൃഷ്‌ടിക്കപ്പെട്ടു, നമുക്ക് ജിറ്റ് റിപ്പോ സമാരംഭിച്ച് കമ്മിറ്റ് ചെയ്യാം:

git init
git add
git commit -m "First API commit"

3. ഒരു പുതിയ Heroku ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുക.

heroku create

ഞങ്ങൾ മാസ്റ്റർ ബ്രാഞ്ചിനെ വിദൂര ഹെറോകു റിപ്പോയിലേക്ക് തള്ളുന്നു:

git push heroku master

കമാൻഡുകൾ ഉപയോഗിച്ച് API സേവനം തുറന്ന് നിങ്ങൾക്ക് ഇപ്പോൾ ആരംഭിക്കാം:

heroku ps:scale web=1
heroku open
 

API ഇവിടെ ലഭ്യമാകും your-random-heroku-name.herokuapp.com/ai-quotes.

RapidAPI മാർക്കറ്റ്‌പ്ലെയ്‌സിലേക്ക് നിങ്ങളുടെ പൈത്തൺ API എങ്ങനെ ചേർക്കാം

നിങ്ങളുടെ API സേവനം Heroku-ൽ പ്രസിദ്ധീകരിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് അത് റാപ്പിഡ് API-ലേക്ക് ചേർക്കാം. ഇവിടെ വിശദമായ ഡോക്യുമെന്റേഷൻ ഈ വിഷയത്തിൽ.

1. ഒരു RapidAPI അക്കൗണ്ട് സൃഷ്ടിക്കുക.

ഒരു സൗജന്യ അക്കൗണ്ട് രജിസ്റ്റർ ചെയ്യുക - ഇത് Facebook, Google, GitHub എന്നിവ ഉപയോഗിച്ച് ചെയ്യാം.

2. നിയന്ത്രണ പാനലിലേക്ക് API ചേർക്കുക.

3. അടുത്തതായി, നിങ്ങളുടെ API-യെക്കുറിച്ചുള്ള പൊതുവായ വിവരങ്ങൾ നൽകുക.

4. "API ചേർക്കുക" ക്ലിക്കുചെയ്തതിനുശേഷം, ഞങ്ങളുടെ API-യെ കുറിച്ചുള്ള വിവരങ്ങൾ നൽകാൻ കഴിയുന്ന ഒരു പുതിയ പേജ് ദൃശ്യമാകുന്നു.

5. ഇപ്പോൾ നിങ്ങൾക്ക് ഒന്നുകിൽ API എൻഡ് പോയിന്റുകൾ സ്വമേധയാ നൽകാം അല്ലെങ്കിൽ ഡൗൺലോഡ് ചെയ്യാം swagger-file OpenAPI ഉപയോഗിക്കുന്നു.

ശരി, ഇപ്പോൾ നമുക്ക് നമ്മുടെ API-യുടെ അവസാന പോയിന്റുകൾ എൻഡ് പോയിന്റ് പേജിൽ സജ്ജീകരിക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ കാര്യത്തിൽ, അവസാന പോയിന്റുകൾ CRUD എന്ന ആശയവുമായി പൊരുത്തപ്പെടുന്നു (നേടുക, പോസ്റ്റ് ചെയ്യുക, ഇടുക, ഇല്ലാതാക്കുക).

അടുത്തതായി, നിങ്ങൾ ക്രമരഹിതമായ ഉദ്ധരണി (ഐഡി ഡിഫോൾട്ടാണെങ്കിൽ) അല്ലെങ്കിൽ നിർദ്ദിഷ്ട ഐഡിക്ക് ഒരു ഉദ്ധരണി പ്രദർശിപ്പിക്കുന്ന ഒരു GET AI ഉദ്ധരണി എൻഡ്‌പോയിന്റ് സൃഷ്‌ടിക്കേണ്ടതുണ്ട്.

ഒരു എൻഡ്‌പോയിന്റ് സൃഷ്‌ടിക്കാൻ, "അവസാന പോയിന്റ് സൃഷ്‌ടിക്കുക" ബട്ടൺ ക്ലിക്കുചെയ്യുക.

മറ്റെല്ലാ എപിഐ എൻഡ് പോയിന്റുകൾക്കുമായി ഞങ്ങൾ ഈ പ്രക്രിയ ആവർത്തിക്കുന്നു. അത്രയേയുള്ളൂ! അഭിനന്ദനങ്ങൾ, നിങ്ങൾ നിങ്ങളുടെ API പ്രസിദ്ധീകരിച്ചു!

എല്ലാം ശരിയാണെങ്കിൽ, API പേജ് ഇതുപോലെ കാണപ്പെടും:

തീരുമാനം

ഈ ലേഖനത്തിൽ, Heroku ക്ലൗഡിലേക്ക് API പ്രസിദ്ധീകരിക്കുകയും RapidAPI ഡയറക്‌ടറിയിലേക്ക് ചേർക്കുകയും ചെയ്യുന്ന പ്രക്രിയയ്‌ക്കൊപ്പം പൈത്തണിൽ നിങ്ങളുടെ സ്വന്തം RESTful API സേവനം സൃഷ്‌ടിക്കുന്ന പ്രക്രിയയും ഞങ്ങൾ പഠിച്ചു.

എന്നാൽ ടെസ്റ്റ് പതിപ്പ് API വികസനത്തിന്റെ അടിസ്ഥാന തത്വങ്ങൾ മാത്രമാണ് കാണിച്ചത് - സുരക്ഷ, തെറ്റ് സഹിഷ്ണുത, സ്കേലബിളിറ്റി തുടങ്ങിയ സൂക്ഷ്മതകൾ പരിഗണിക്കപ്പെട്ടില്ല.

ഒരു യഥാർത്ഥ API വികസിപ്പിക്കുമ്പോൾ, ഇതെല്ലാം കണക്കിലെടുക്കേണ്ടതുണ്ട്.

അവലംബം: www.habr.com