ನೀವು ಈ ಲೇಖನವನ್ನು ಓದುತ್ತಿದ್ದರೆ, API (ಅಪ್ಲಿಕೇಶನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಇಂಟರ್ಫೇಸ್) ಅನ್ನು ಬಳಸುವಾಗ ತೆರೆಯುವ ಸಾಧ್ಯತೆಗಳ ಬಗ್ಗೆ ನೀವು ಈಗಾಗಲೇ ತಿಳಿದಿರುತ್ತೀರಿ.
ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹಲವಾರು ಸಾರ್ವಜನಿಕ API ಗಳಲ್ಲಿ ಒಂದನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ನೀವು ಈ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಬಹುದು ಅಥವಾ ಅಗತ್ಯ ಡೇಟಾದೊಂದಿಗೆ ಪೂರಕಗೊಳಿಸಬಹುದು. ಆದರೆ ನೀವು ಸಮುದಾಯದೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸುವ ವಿಶಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದರೆ ಏನು?
ಉತ್ತರ ಸರಳವಾಗಿದೆ: ನಿಮಗೆ ಅಗತ್ಯವಿದೆ .
ಇದು ಮೊದಲಿಗೆ ಬೆದರಿಸುವ ಕೆಲಸದಂತೆ ತೋರುತ್ತಿದ್ದರೂ, ವಾಸ್ತವವಾಗಿ ಇದು ತುಂಬಾ ಸರಳವಾಗಿದೆ. ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ.
ನೀವು ಪ್ರಾರಂಭಿಸಲು ಏನು ಬೇಕು
API ಅಭಿವೃದ್ಧಿಗೆ ಅಗತ್ಯವಿದೆ:
- ಪೈಥಾನ್ 3;
- - ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಸರಳ ಮತ್ತು ಬಳಸಲು ಸುಲಭವಾದ ಚೌಕಟ್ಟು;
- Flask ಗಾಗಿ ವಿಸ್ತರಣೆಯಾಗಿದ್ದು ಅದು REST API ಅನ್ನು ತ್ವರಿತವಾಗಿ ಮತ್ತು ಕನಿಷ್ಠ ಸೆಟಪ್‌ನೊಂದಿಗೆ ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಅನುಸ್ಥಾಪನೆಯನ್ನು ಆಜ್ಞೆಯಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ:
pip install flask-restfulಆರಂಭಿಕರಿಗಾಗಿ ಉಚಿತ ತೀವ್ರವಾದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ನಾವು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ:
- ಆಗಸ್ಟ್ 26-28. ಸಹಾಯಕ ಬಾಟ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಟೆಲಿಗ್ರಾಮ್ API ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಇತರ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಉಚಿತ ತೀವ್ರವಾದ. ಅಗ್ರ ಮೂರು ಭಾಗವಹಿಸುವವರು ಸ್ಕಿಲ್ಬಾಕ್ಸ್ನಿಂದ 30 ರೂಬಲ್ಸ್ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ.
ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು
ನಾವು ಮೂಲಭೂತವಾಗಿ RESTful API ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಿದ್ದೇವೆ .
ಕಾರ್ಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮೇಲೆ ತಿಳಿಸಲಾದ ಎರಡು ಪದಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.
REST ಎಂದರೇನು?
REST API (ಪ್ರಾತಿನಿಧಿಕ ರಾಜ್ಯ ವರ್ಗಾವಣೆ) ಡೇಟಾ ವಿನಿಮಯಕ್ಕಾಗಿ HTTP ವಿನಂತಿಗಳನ್ನು ಬಳಸುವ 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 ವಿಧಾನದಿಂದ ಪ್ರಾರಂಭಿಸೋಣ
ಅದರ ID ಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ನಿರ್ದಿಷ್ಟ ಉಲ್ಲೇಖವನ್ನು ಪಡೆಯಲು ಅಥವಾ ಯಾವುದೇ ID ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ ಯಾದೃಚ್ಛಿಕ ಉಲ್ಲೇಖವನ್ನು ಪಡೆಯಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
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", 404ID ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದ್ದರೆ GET ವಿಧಾನವು ಯಾದೃಚ್ಛಿಕ ಉಲ್ಲೇಖವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ. ವಿಧಾನಕ್ಕೆ ಕರೆ ಮಾಡುವಾಗ ID ಅನ್ನು ಹೊಂದಿಸಲಾಗಿಲ್ಲ.
ಅದನ್ನು ಹೊಂದಿಸಿದರೆ, ನಂತರ ವಿಧಾನವು ಉಲ್ಲೇಖಗಳ ನಡುವೆ ಹುಡುಕುತ್ತದೆ ಮತ್ತು ನೀಡಲಾದ ID ಅನ್ನು ಹೊಂದಿರುವದನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ. ಏನೂ ಕಂಡುಬಂದಿಲ್ಲವಾದರೆ, "ಉದ್ಧರಣ ಕಂಡುಬಂದಿಲ್ಲ, 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 ಅನ್ನು ಬಳಸಿಕೊಂಡು, ಇದು ಲೇಖಕರನ್ನು ಹಿಂಪಡೆಯಿತು ಮತ್ತು ವಿನಂತಿಯಿಂದ ಉಲ್ಲೇಖಿಸಿ, ಅವುಗಳನ್ನು ಪ್ಯಾರಮ್‌ಗಳ ನಿಘಂಟಿನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಯೊಂದಿಗೆ ಉಲ್ಲೇಖವು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ನಂತರ ವಿಧಾನವು ಸೂಕ್ತವಾದ ಸಂದೇಶ ಮತ್ತು ಕೋಡ್ 400 ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಯೊಂದಿಗೆ ಉಲ್ಲೇಖವನ್ನು ಇನ್ನೂ ರಚಿಸದಿದ್ದರೆ, ವಿಧಾನವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಮತ್ತು ಲೇಖಕರ ಜೊತೆಗೆ ಇತರ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಹೊಸ ನಮೂದನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ನಂತರ 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 ವಿಧಾನವು ID ಮತ್ತು ಇನ್‌ಪುಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು reqparse ಅನ್ನು ಬಳಸಿಕೊಂಡು ಉಲ್ಲೇಖ ನಿಯತಾಂಕಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ.
ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಯೊಂದಿಗೆ ಉಲ್ಲೇಖವು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ, ವಿಧಾನವು ಅದನ್ನು ಹೊಸ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ನವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ನವೀಕರಿಸಿದ ಉಲ್ಲೇಖವನ್ನು ಕೋಡ್ 200 ನೊಂದಿಗೆ ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ. ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಯೊಂದಿಗೆ ಇನ್ನೂ ಯಾವುದೇ ಉಲ್ಲೇಖವಿಲ್ಲದಿದ್ದರೆ, ಕೋಡ್ 201 ನೊಂದಿಗೆ ಹೊಸ ದಾಖಲೆಯನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಇನ್ನು ಮುಂದೆ ಸ್ಪೂರ್ತಿದಾಯಕವಲ್ಲದ ಉಲ್ಲೇಖವನ್ನು ತೆಗೆದುಹಾಕಲು ಅಳಿಸುವ ವಿಧಾನವನ್ನು ರಚಿಸೋಣ.
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ಎಲ್ಲವೂ ಸರಿಯಾಗಿದ್ದರೆ, ನಾವು ಈ ರೀತಿಯದನ್ನು ಪಡೆಯುತ್ತೇವೆ:
* ಡೀಬಗ್ ಮೋಡ್: ಆನ್
* ಚಾಲನೆಯಲ್ಲಿದೆ :5000/ (ನಿರ್ಗಮಿಸಲು CTRL+C ಒತ್ತಿರಿ)
* ಸ್ಟ್ಯಾಟ್‌ನೊಂದಿಗೆ ಮರುಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ
* ಡೀಬಗರ್ ಸಕ್ರಿಯವಾಗಿದೆ!
* ಡೀಬಗರ್ ಪಿನ್: XXXXXXX
API ಅನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
API ಅನ್ನು ರಚಿಸಿದ ನಂತರ, ಅದನ್ನು ಪರೀಕ್ಷಿಸಬೇಕಾಗಿದೆ.
ಇದನ್ನು ಕರ್ಲ್ ಕನ್ಸೋಲ್ ಉಪಯುಕ್ತತೆ ಅಥವಾ ನಿದ್ರಾಹೀನತೆ REST ಕ್ಲೈಂಟ್ ಬಳಸಿ ಅಥವಾ ರಾಪಿಡ್ API ನಲ್ಲಿ API ಅನ್ನು ಪ್ರಕಟಿಸುವ ಮೂಲಕ ಮಾಡಬಹುದು.
ನಮ್ಮ API ಅನ್ನು ಪ್ರಕಟಿಸಲಾಗುತ್ತಿದೆ
RapidAPI 10 API ಗಳನ್ನು (ಮತ್ತು ಸುಮಾರು 000 ಮಿಲಿಯನ್ ಡೆವಲಪರ್‌ಗಳು) ಹೊಂದಿರುವ ವಿಶ್ವದ ಅತಿದೊಡ್ಡ ಮಾರುಕಟ್ಟೆ ಸ್ಥಳವಾಗಿದೆ.
RapidAPI ಥರ್ಡ್-ಪಾರ್ಟಿ API ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಒಂದೇ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ ನಿಮ್ಮ ಸ್ವಂತ API ಅನ್ನು ತ್ವರಿತವಾಗಿ ಮತ್ತು ಸುಲಭವಾಗಿ ಪ್ರಕಟಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಗೆ , ನೀವು ಮೊದಲು ಅದನ್ನು ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿರುವ ಕೆಲವು ಸರ್ವರ್‌ಗೆ ಪ್ರಕಟಿಸಬೇಕಾಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಬಳಸುತ್ತೇವೆ . ಅವನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಯಾವುದೇ ತೊಂದರೆಗಳನ್ನು ಉಂಟುಮಾಡಬಾರದು, ().
Heroku ನಲ್ಲಿ ನಿಮ್ಮ API ಅನ್ನು ಹೇಗೆ ಪ್ರಕಟಿಸುವುದು
1. Heroku ಸ್ಥಾಪಿಸಿ.
Heroku ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಫೇಸ್ (CLI) ಅನ್ನು ನೋಂದಾಯಿಸುವುದು ಮತ್ತು ಸ್ಥಾಪಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ. ಇದು ಉಬುಂಟು 16+ ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಸುಡೋ ಸ್ನ್ಯಾಪ್ ಇನ್‌ಸ್ಟಾಲ್ ಹೀರೋಕು --ಕ್ಲಾಸಿಕ್
ನಂತರ ನಾವು ಲಾಗ್ ಇನ್ ಮಾಡುತ್ತೇವೆ:
ನಾಯಕ ಲಾಗಿನ್
2. ಅಗತ್ಯ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಿ.
ಈಗ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿರುವ ಫೋಲ್ಡರ್‌ಗೆ ಪ್ರಕಟಿಸಲು ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ:
- ಅಗತ್ಯವಿರುವ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ಪಟ್ಟಿಯೊಂದಿಗೆ ಅವಶ್ಯಕತೆಗಳು.txt;
- ಪ್ರೋಕ್ಫೈಲ್, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಯಾವ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ;
- .gitignore - ಸರ್ವರ್‌ನಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲದ ಫೈಲ್‌ಗಳನ್ನು ಹೊರಗಿಡಲು.
ಅವಶ್ಯಕತೆಗಳು.txt ಫೈಲ್ ಈ ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ:
- ಫ್ಲಾಸ್ಕ್
- ಫ್ಲಾಸ್ಕ್-ವಿಶ್ರಾಂತಿ
- ಗುನಿಕಾರ್ನ್
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಬೇಕಾಗಿರುವುದರಿಂದ ನಾವು ಪಟ್ಟಿಗೆ ಗನ್‌ಕಾರ್ನ್ (ಪೈಥಾನ್ WSGI HTTP ಸರ್ವರ್) ಅನ್ನು ಸೇರಿಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.
ಪ್ರೊಫೈಲ್ ಒಳಗೊಂಡಿರುತ್ತದೆ:
ವೆಬ್: ಗುನಿಕಾರ್ನ್ ಅಪ್ಲಿಕೇಶನ್: ಅಪ್ಲಿಕೇಶನ್
.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 ಇಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ .
ನಿಮ್ಮ ಪೈಥಾನ್ API ಅನ್ನು RapidAPI ಮಾರುಕಟ್ಟೆಗೆ ಹೇಗೆ ಸೇರಿಸುವುದು
API ಸೇವೆಯನ್ನು Heroku ನಲ್ಲಿ ಪ್ರಕಟಿಸಿದ ನಂತರ, ನೀವು ಅದನ್ನು Rapid API ಗೆ ಸೇರಿಸಬಹುದು. ಇಲ್ಲಿ ಈ ವಿಷಯದ ಮೇಲೆ.
1. RapidAPI ಖಾತೆಯನ್ನು ರಚಿಸಿ.
ನಾವು ಉಚಿತ ಖಾತೆಯನ್ನು ನೋಂದಾಯಿಸುತ್ತೇವೆ - ಇದನ್ನು Facebook, Google, GitHub ಬಳಸಿ ಮಾಡಬಹುದು.
2. ನಿಯಂತ್ರಣ ಫಲಕಕ್ಕೆ API ಸೇರಿಸಿ.
3. ಮುಂದೆ, ನಿಮ್ಮ API ಕುರಿತು ಸಾಮಾನ್ಯ ಮಾಹಿತಿಯನ್ನು ನಮೂದಿಸಿ.
4. "API ಸೇರಿಸು" ಕ್ಲಿಕ್ ಮಾಡಿದ ನಂತರ ನಮ್ಮ API ಕುರಿತು ನೀವು ಮಾಹಿತಿಯನ್ನು ನಮೂದಿಸಬಹುದಾದ ಹೊಸ ಪುಟವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.
5. ಈಗ ನೀವು API ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಮೂದಿಸಬಹುದು ಅಥವಾ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು OpenAPI ಬಳಸಿ.
ಸರಿ, ಈಗ ನೀವು ಅಂತ್ಯಬಿಂದುಗಳ ಪುಟದಲ್ಲಿ ನಮ್ಮ API ನ ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಅಂತಿಮ ಬಿಂದುಗಳು CRUD ಪರಿಕಲ್ಪನೆಗೆ ಸಂಬಂಧಿಸಿವೆ (ಪಡೆಯಿರಿ, ಪೋಸ್ಟ್ ಮಾಡಿ, ಇರಿಸಿ, ಅಳಿಸಿ).
ಮುಂದೆ, ನೀವು ಯಾದೃಚ್ಛಿಕ ಉಲ್ಲೇಖವನ್ನು (ID ಡೀಫಾಲ್ಟ್ ಆಗಿದ್ದರೆ) ಅಥವಾ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ID ಗಾಗಿ ಉಲ್ಲೇಖವನ್ನು ಪ್ರದರ್ಶಿಸುವ GET AI ಕೋಟ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ.
ಅಂತಿಮ ಬಿಂದುವನ್ನು ರಚಿಸಲು, ನೀವು "ಅಂತ್ಯ ಬಿಂದುವನ್ನು ರಚಿಸಿ" ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಎಲ್ಲಾ ಇತರ API ಅಂತಿಮ ಬಿಂದುಗಳಿಗಾಗಿ ನಾವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ. ಅಷ್ಟೇ! ಅಭಿನಂದನೆಗಳು, ನಿಮ್ಮ API ಅನ್ನು ನೀವು ಪ್ರಕಟಿಸಿರುವಿರಿ!
ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆದರೆ, API ಪುಟವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ತೀರ್ಮಾನಕ್ಕೆ
ಈ ಲೇಖನದಲ್ಲಿ, API ಅನ್ನು Heroku ಕ್ಲೌಡ್‌ಗೆ ಪ್ರಕಟಿಸುವ ಮತ್ತು RapidAPI ಡೈರೆಕ್ಟರಿಗೆ ಸೇರಿಸುವ ಪ್ರಕ್ರಿಯೆಯೊಂದಿಗೆ ಪೈಥಾನ್‌ನಲ್ಲಿ ನಮ್ಮದೇ ಆದ RESTful API ಸೇವೆಯನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಾವು ನಡೆದಿದ್ದೇವೆ.
ಆದರೆ ಪರೀಕ್ಷಾ ಆವೃತ್ತಿಯಲ್ಲಿ, API ಅಭಿವೃದ್ಧಿಯ ಮೂಲ ತತ್ವಗಳನ್ನು ಮಾತ್ರ ತೋರಿಸಲಾಗಿದೆ - ಭದ್ರತೆ, ತಪ್ಪು ಸಹಿಷ್ಣುತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿ ಮುಂತಾದ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗಿಲ್ಲ.
ನಿಜವಾದ API ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಇದೆಲ್ಲವನ್ನೂ ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು.
ಮೂಲ: www.habr.com