நீங்கள் இந்தக் கட்டுரையைப் படிக்கிறீர்கள் என்றால், API (Application Programming Interface) ஐப் பயன்படுத்துவதன் மூலம் வரும் சாத்தியக்கூறுகளை நீங்கள் ஏற்கனவே அறிந்திருக்கலாம்.
உங்கள் பயன்பாட்டில் பல திறந்த APIகளில் ஒன்றைச் சேர்ப்பதன் மூலம், நீங்கள் பயன்பாட்டின் செயல்பாட்டை நீட்டிக்கலாம் அல்லது தேவையான தரவுகளுடன் அதை மேம்படுத்தலாம். ஆனால் நீங்கள் சமூகத்துடன் பகிர்ந்து கொள்ள விரும்பும் தனித்துவமான அம்சத்தை உருவாக்கினால் என்ன செய்வது?
பதில் எளிது: உங்களுக்குத் தேவை .
முதலில் இது கடினமான பணியாகத் தோன்றினாலும், உண்மையில் இது எளிமையானது. பைத்தானைப் பயன்படுத்தி இதை எப்படி செய்வது என்று நாங்கள் உங்களுக்குக் காண்பிப்போம்.
நீங்கள் தொடங்குவதற்கு என்ன தேவை
API ஐ உருவாக்க உங்களுக்குத் தேவை:
- பைதான் 3;
- - இணைய பயன்பாடுகளை உருவாக்குவதற்கான எளிய மற்றும் பயன்படுத்த எளிதான கட்டமைப்பு;
- ஃப்ளாஸ்கிற்கான நீட்டிப்பாகும், இது REST API ஐ விரைவாகவும் குறைந்த கட்டமைப்புடனும் உருவாக்க அனுமதிக்கிறது.
கட்டளையுடன் நிறுவல் செய்யப்படுகிறது:
pip install flask-restfulஆரம்பநிலைக்கு ஒரு இலவச தீவிர நிரலாக்க பாடத்தை நாங்கள் பரிந்துரைக்கிறோம்:
- ஆகஸ்ட் 26-28. அசிஸ்டண்ட் போட்கள் எவ்வாறு செயல்படுகின்றன, டெலிகிராம் ஏபிஐயுடன் பணிபுரியும் பிரத்தியேகங்கள் மற்றும் பிற நுணுக்கங்களைப் புரிந்துகொள்ள உங்களை அனுமதிக்கும் இலவச தீவிர பாடநெறி. மூன்று சிறந்த பங்கேற்பாளர்கள் ஸ்கில்பாக்ஸிலிருந்து 30 ரூபிள் பெறுவார்கள்.
நீங்கள் தொடங்குவதற்கு முன்
அடிப்படையுடன் கூடிய RESTful API ஐ உருவாக்கப் போகிறோம் .
பணியை முழுமையாகப் புரிந்து கொள்ள, மேலே குறிப்பிட்டுள்ள இரண்டு சொற்களைப் புரிந்து கொள்வோம்.
REST என்றால் என்ன?
REST API (Representational State Transfer) என்பது தரவு பரிமாற்றத்திற்கு HTTP கோரிக்கைகளைப் பயன்படுத்தும் API ஆகும்.
REST APIகள் சில நிபந்தனைகளை பூர்த்தி செய்ய வேண்டும்:
- கிளையண்ட்-சர்வர் கட்டமைப்பு: கிளையன்ட் பயனர் இடைமுகத்துடன் தொடர்பு கொள்கிறது, மேலும் சேவையகம் பின்தளம் மற்றும் தரவு சேமிப்பகத்துடன் தொடர்பு கொள்கிறது. கிளையன்ட் மற்றும் சர்வர் சுயாதீனமானவை, அவற்றில் ஏதேனும் ஒன்றை மற்றொன்றிலிருந்து தனித்தனியாக மாற்றலாம்.
- நிலையற்றது - சேவையகத்தில் கிளையன்ட் தரவு எதுவும் சேமிக்கப்படவில்லை. அமர்வு நிலை கிளையன்ட் பக்கத்தில் சேமிக்கப்படுகிறது.
- Cacheability - வாடிக்கையாளர்கள் ஒட்டுமொத்த செயல்திறனை மேம்படுத்த சர்வர் பதில்களை கேச் செய்யலாம்.
CRUD என்றால் என்ன?
ரா நான்கு அடிப்படைச் செயல்களை (உருவாக்கு, படிக்க, புதுப்பித்தல் மற்றும் நீக்குதல்) விவரிக்கும் ஒரு நிரலாக்கக் கருத்தாகும்.
REST API இல், இடுகை, பெறுதல், போடுதல், நீக்குதல் போன்ற செயல்களுக்கு கோரிக்கை வகைகள் மற்றும் கோரிக்கை முறைகள் பொறுப்பாகும்.
இப்போது அடிப்படை விதிமுறைகளைப் புரிந்துகொண்ட பிறகு, API ஐ உருவாக்கத் தொடங்கலாம்.
வடிவமைப்பு
செயற்கை நுண்ணறிவு பற்றிய மேற்கோள்களின் களஞ்சியத்தை உருவாக்குவோம். AI என்பது இன்று வேகமாக வளர்ந்து வரும் தொழில்நுட்பங்களில் ஒன்றாகும், மேலும் AI உடன் பணிபுரிவதற்கான பிரபலமான கருவியாக Python உள்ளது.
இந்த API மூலம், பைதான் டெவலப்பர் AI பற்றிய தகவல்களை விரைவாகப் பெறலாம் மற்றும் புதிய முன்னேற்றங்களால் ஈர்க்கப்படலாம். ஒரு டெவலப்பருக்கு இந்த தலைப்பில் மதிப்புமிக்க எண்ணங்கள் இருந்தால், அவர் அவற்றை களஞ்சியத்தில் சேர்க்க முடியும்.
தேவையான தொகுதிகளை இறக்குமதி செய்து பிளாஸ்கை அமைப்பதன் மூலம் தொடங்குவோம்:
from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)இந்தத் துணுக்கில், Flask, Api மற்றும் Resource ஆகியவை நமக்குத் தேவையான வகுப்புகள்.
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 ஐப் பயன்படுத்தி, வினவலில் இருந்து ஆசிரியரையும் மேற்கோளையும் மீட்டெடுத்தது, அவற்றை params அகராதியில் சேமித்து வைத்தது.
குறிப்பிட்ட ஐடியுடன் மேற்கோள் ஏற்கனவே இருந்தால், முறையானது தொடர்புடைய செய்தியையும் குறியீடு 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, 201PUT முறை, முந்தைய உதாரணத்தைப் போலவே, ஐடி மற்றும் உள்ளீட்டை எடுத்து, 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 இல் ஒரு ஆதாரத்தைச் சேர்த்து, பாதையை அமைத்து, Flask ஐ இயக்கவும்.
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எல்லாம் நன்றாக இருந்தால், இது போன்ற ஒன்றைப் பெறுவோம்:
* பிழைத்திருத்த முறை: ஆன்
* இயங்குகிறது :5000/ (வெளியேற CTRL+C ஐ அழுத்தவும்)
* புள்ளிவிவரத்துடன் மறுதொடக்கம்
* பிழைத்திருத்தி செயலில் உள்ளது!
* பிழைத்திருத்த PIN: XXXXXXX
API ஐ சோதிக்கிறது
API உருவாக்கப்பட்டவுடன், அது சோதிக்கப்பட வேண்டும்.
கர்ல் கன்சோல் பயன்பாடு அல்லது இன்சோம்னியா ரெஸ்ட் கிளையண்ட் அல்லது ரேபிட் ஏபிஐயில் ஏபிஐ வெளியிடுவதன் மூலம் இதைச் செய்யலாம்.
எங்கள் API ஐ வெளியிடுகிறது
RapidAPI என்பது 10க்கும் மேற்பட்ட APIகளைக் கொண்ட உலகின் மிகப்பெரிய சந்தையாகும் (மற்றும் சுமார் 000 மில்லியன் டெவலப்பர்கள்).
RapidAPI ஆனது மூன்றாம் தரப்பு APIகளுடன் பணிபுரிவதற்கான ஒற்றை இடைமுகத்தை வழங்குவது மட்டுமல்லாமல், உங்கள் சொந்த API ஐ விரைவாகவும் எளிதாகவும் வெளியிடும் திறனையும் வழங்குகிறது.
செய்ய , நீங்கள் முதலில் அதை நெட்வொர்க்கில் உள்ள சில சர்வரில் வெளியிட வேண்டும். எங்கள் விஷயத்தில் நாங்கள் பயன்படுத்துவோம் . அதனுடன் பணிபுரிவது எந்த சிரமத்தையும் ஏற்படுத்தக்கூடாது, ().
Heroku இல் உங்கள் API ஐ எவ்வாறு வெளியிடுவது
1. Heroku ஐ நிறுவவும்.
முதல் படி, Heroku கட்டளை வரி இடைமுகத்தை (CLI) பதிவு செய்து நிறுவ வேண்டும். இது உபுண்டு 16+ இல் வேலை செய்கிறது.
sudo snap install heroku —classic
பின்னர் உள்நுழைக:
ஹீரோகு உள்நுழைவு
2. தேவையான கோப்புகளைச் சேர்க்கவும்.
இப்போது எங்கள் பயன்பாட்டில் உள்ள கோப்புறையில் வெளியிட வேண்டிய கோப்புகளைச் சேர்க்க வேண்டும்:
- தேவைகள்.txt தேவையான பைதான் தொகுதிகள் பட்டியலுடன்;
- Procfile, இது பயன்பாட்டை இயக்க என்ன கட்டளைகளை செயல்படுத்த வேண்டும் என்பதைக் குறிப்பிடுகிறது;
- .gitignore - சர்வரில் தேவையில்லாத கோப்புகளை விலக்க.
requirements.txt கோப்பில் பின்வரும் வரிகள் இருக்கும்:
- குடுவை
- குடுவை-ஓய்வு
- குனிகார்ன்
எங்கள் பயன்பாட்டை சர்வரில் இயக்க வேண்டியிருப்பதால், பட்டியலில் குனிகார்னை (பைதான் WSGI HTTP சர்வர்) சேர்த்துள்ளோம் என்பதை நினைவில் கொள்ளவும்.
சுயவிவரத்தில் பின்வருவன அடங்கும்:
web: gunicorn app:app
.gitignore இன் உள்ளடக்கங்கள்:
*.pyc
__pycache__/இப்போது கோப்புகள் உருவாக்கப்பட்டுவிட்டதால், git repo ஐ துவக்கி உறுதியளிக்கவும்:
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 இல் கிடைக்கும் .
RapidAPI சந்தையில் உங்கள் பைதான் API ஐ எவ்வாறு சேர்ப்பது
உங்கள் API சேவை Heroku இல் வெளியிடப்பட்டதும், நீங்கள் அதை Rapid API இல் சேர்க்கலாம். இங்கே இந்த தலைப்பில்.
1. RapidAPI கணக்கை உருவாக்கவும்.
இலவச கணக்கை பதிவு செய்யவும் - இதை Facebook, Google, GitHub ஐப் பயன்படுத்தி செய்யலாம்.
2. API ஐ கட்டுப்பாட்டு பலகத்தில் சேர்க்கவும்.
3. அடுத்து, உங்கள் API பற்றிய பொதுவான தகவலை உள்ளிடவும்.
4. "API ஐச் சேர்" என்பதைக் கிளிக் செய்த பிறகு, எங்கள் API பற்றிய தகவலை உள்ளிடக்கூடிய புதிய பக்கம் தோன்றும்.
5. இப்போது நீங்கள் ஏபிஐ இறுதிப்புள்ளிகளை கைமுறையாக உள்ளிடலாம் அல்லது பதிவிறக்கம் செய்யலாம் OpenAPI ஐப் பயன்படுத்துகிறது.
சரி, இப்போது நமது API இன் இறுதிப்புள்ளிகளை எண்ட்பாயிண்ட்ஸ் பக்கத்தில் அமைக்க வேண்டும். எங்கள் விஷயத்தில், இறுதிப்புள்ளிகள் CRUD (பெறவும், இடுகையிடவும், வைக்கவும், நீக்கவும்) கருத்துடன் ஒத்துப்போகின்றன.
அடுத்து, நீங்கள் ஒரு GET AI மேற்கோள் இறுதிப்புள்ளியை உருவாக்க வேண்டும், அது சீரற்ற மேற்கோளை (ஐடி இயல்புநிலையாக இருந்தால்) அல்லது குறிப்பிட்ட ஐடிக்கான மேற்கோளைக் காண்பிக்கும்.
இறுதிப்புள்ளியை உருவாக்க, "முடிவுப்புள்ளியை உருவாக்கு" பொத்தானைக் கிளிக் செய்யவும்.
மற்ற அனைத்து API இறுதிப்புள்ளிகளுக்கும் இந்த செயல்முறையை மீண்டும் செய்கிறோம். அவ்வளவுதான்! வாழ்த்துக்கள், உங்கள் API ஐ வெளியிட்டுவிட்டீர்கள்!
எல்லாம் சரியாக இருந்தால், API பக்கம் இப்படி இருக்கும்:
முடிவுக்கு
இந்தக் கட்டுரையில், பைத்தானில் உங்கள் சொந்த RESTful API சேவையை உருவாக்கும் செயல்முறையையும், API ஐ Heroku மேகக்கணியில் வெளியிட்டு RapidAPI கோப்பகத்தில் சேர்க்கும் செயல்முறையையும் கற்றுக்கொண்டோம்.
ஆனால் சோதனை பதிப்பு API வளர்ச்சியின் அடிப்படைக் கொள்கைகளை மட்டுமே காட்டியது - பாதுகாப்பு, தவறு சகிப்புத்தன்மை மற்றும் அளவிடுதல் போன்ற நுணுக்கங்கள் கருதப்படவில்லை.
உண்மையான API ஐ உருவாக்கும் போது, இவை அனைத்தும் கணக்கில் எடுத்துக்கொள்ளப்பட வேண்டும்.
ஆதாரம்: www.habr.com