You must define a web server that uses the API or APIs you have created. Endpoints Frameworks for Python implements the standard Web Server Gateway Interface (WSGI) to route requests to your API to the methods in your code.
As with every application that runs on App Engine, you must create a file
app.yaml in which you
configure your App Engine app's settings. To define the web server,
you make changes to your
app.yaml as described below.
To define a web server:
Create a Python module, for example
main.py, and create an
endpoints.api_serverobject at the top-level:
api = endpoints.api_server([EchoApi])
api = endpoints.api_server([EchoApi])creates a WSGI app that routes API requests to the methods in the
You can provide a list of
remote.Serviceobjects (which you defined when you created your API) to
endpoints.api_server. If you have an API that is implemented in several classes, then your
remote.Serviceobject is a collection of classes as described in Creating an API Implemented with Multiple Classes.
Whether you create a separate module for the
endpoints.api_serverobject depends on whether you created a single API or multiple APIs.
If you are created multiple APIs (using multiple
remote.Servicesubclasses) that are defined in multiple files, then we recommend that you create a separate module for the
endpoints.api_serverobject so that you can import all the class files.
If you created a single API, you can add the required
endpoints.api_servercode to the module where you define your API because you don't need to import any other classes.
app.yamlfile, map the web server you just created to the endpoints location as follows:
handlers: # The endpoints handler must be mapped to /_ah/api. - url: /_ah/api/.* script: main.api
mainis the Python module you in which you defined the
Serving your API from a different path
Optional: To serve your API from a different path, for example
Modify the decorator:
@endpoints.api(name='echo', version='v1', base_path='/api/')
handlers: - url: /api/.* script: main.api
Logging in Endpoints Framework for Python
Endpoints Framework for Python uses the standard Python logging module to log information about the application status and request lifecycle. To learn more about App Engine logs and how to view them, see Reading and Writing Application Logs in the App Engine documentation.
The Python logging module provides predefined log levels. In increasing order of severity, the log levels are:
||Provides detailed logs. Typically you set this level only when troubleshooting a problem.|
||The default log level for Endpoints Frameworks. Allows you to trace the progress of the application at a high level.|
||Alerts you that something unexpected happened, but the application can recover and still run normally.|
||Alerts you that an error happened that might cause some loss of functionality, but the application is still running.|
||Alerts you that a serious error or event happened that might cause the application to shutdown.|
Loggers exist in a dot-separated hierarchy. For example, the logger
endpoints.api_config is a child of the logger
endpoints. This hierarchy
allows you precise control over which logs are emitted or suppressed. Typically,
you only change the two root loggers for Endpoints Frameworks:
DEBUG logging for Endpoints Frameworks
To avoid overloading the log reader, Endpoints Frameworks sets its loggers to
only record log entries with the
INFO log level or above. At any time after
Endpoints Frameworks has been imported into your module, you can change the log
level as follows:
import logging logging.getLogger('endpoints').setLevel(logging.DEBUG) logging.getLogger('endpoints_management').setLevel(logging.DEBUG)
setLevel method sets the minimum log level for the logger.