Shulou(Shulou.com)06/01 Report--

This article shows you how to use Layer in the cloud function SCF to achieve easy deployment. The content is concise and easy to understand, which will definitely brighten your eyes. I hope you can get something through the detailed introduction of this article.

When using cloud functions for project development, when the number of functions increases, one of the problems often encountered is the management of the dependent libraries of these functions. When creating or updating a cloud function, the business code of the function needs to be packaged and uploaded together with the dependent library, so when developing locally, the dependent library and the business code are often placed in a folder.

In this case, there is a set of dependent library code under the code directory of each cloud function, and many of these codes are repeated in several functions, which not only takes up a lot of space, but also has trouble in management. when some dependent libraries need to be upgraded, go to each function project to check the dependency and upgrade operation. On the other hand, these dependent libraries usually do not change much, but they need to be packaged and uploaded with the business code every time the function is updated, so that the actual code update may be only one or two lines. however, you need to generate a 10-megabyte or even 10-megabyte package to upload, and you still need to endure slow upload speed in a bad network environment.

The layer feature recently introduced by Tencent Cloud's SCF function is a product feature prepared for such dependent libraries or static files that do not change frequently. By using the layer function to store and manage the dependent library, and binding with the function as needed, the multi-function sharing of the dependent library can be realized. Only one copy can be uploaded and can be bound and referenced in multiple functions to be used. By binding with the cloud function, it means that there is no need to attach the corresponding dependent library to the business code of the cloud function, and the business code and the dependent library can be managed and deployed separately. Reduce the size of the package that needs to be submitted each time the cloud function is uploaded, and speed up the upload and update speed.

Before the introduction of the actual case, let's introduce the function points of the layer.

As a resource independent of cloud function, layer has an independent creation and management process. Similar to function creation, you can submit the file content to the cloud and create a layer by uploading the zip package, selecting a folder on the console, or uploading the zip package to cos in advance and then referencing it. Each package submitted to the layer will generate a new version.

Therefore, after you create a layer, you will have the first version; later, if the dependent library or file content is upgraded, you can continue to update the layer and generate a new version, with the version number increasing in turn. When you create a layer, or release a new version, you can also specify the runtime that the current layer can support, so that the functions of the corresponding runtime can browse or bind the current layer.

When using the layer, the cloud function is bound to the specific version of the specific layer to achieve the introduction and use of the layer content. In the configuration management interface of the function, the binding configuration interface of the layer is added. The binding operation can be completed by selecting the layer and the version of the desired binding. After the layer is bound, there will be the contents of the layer in the / opt directory in the runtime environment when the function is running. Of course, the NODE_PATH,PYTHONPATH in the system has already specified the / opt directory. If the bound layer contains dependent libraries, it can be directly referenced in the function code through methods such as import,require, which is consistent with the conventional writing, and does not need to specify additional paths. At the same time, a function currently supports binding versions of up to five layers, so you can introduce the required dependent libraries into the layers in this way.

When multiple layers are bound to the same function, there is a certain order relationship between the layers. The layers are loaded sequentially. If there is a file with the same name under the same path, it will cause the problem that the loaded file overrides the file first. You need to pay attention to whether there is content overwriting when multiple layers are bound. And whether the loading sequence is based on its own control needs. On the other hand, the binding relationship between layers and functions is also saved as the configuration of functions. The $LATEST version of the function can modify the binding configuration as needed, but once the release version is released, the configuration in the generated function version is fixed and cannot be modified again. Therefore, solidifying the developed version by releasing the version can avoid the unavailability of the code caused by the modification of the function code or the content of the layer.

Next, we will introduce the use of layer functionality through a use case.

In this case, we will implement a call test website and send a message to the cmq message queue when an exception is detected. This cloud function is written by python and will use two dependent libraries, the requests library to implement http access detection of url addresses, and the cmq library to send messages to cmq queues.

Before creating the function, I will use these two libraries to create two layers, and later bind the function to these two layers to use the dependent library.

First, create two folders locally: requests-lib and cmq-lib

After entering the requests-lib folder from the command line, execute the command

Pip install requests-t

Download and install the requests library in this directory. In the cmq-lib folder, we download the sdk of cmq locally by downloading or clone https://github.com/tencentyun/cmq-python-sdk project.

Next, use these two folders to create two layers

Also named requests-lib and cmq-lib

Create it by directly selecting a folder and selecting the appropriate runtime as python2

After the two layers are created, they both have version 1 available for function binding.

At the same time, I have also created a cmq queue named testq in the same region, and prepared account id,secret id,secret key and other information according to the needs of sdk.

Next, I will use the following code to create the function detect-sendmsg, implement the dialing test of url, and send messages to the cmq message queue. The appid, secretid and secretkey in the code need to be replaced with the relevant content under your own account.

#-*-coding: utf8-*-import jsonimport loggingimport osfrom cmq.account import Accountfrom cmq.cmq_exception import * from cmq.topic import * import requestslogger = logging.getLogger () logger.setLevel (logging.DEBUG) print ('Loading function') appid = 1252724xxx # please change to your appid. Find it in Account InfosecretId = 'AKIDkkxxxxxxxxxxxxxxx' # please change to your API secret id. Find it in API secret key pairsecretKey = 'xxxxxxxxxxxxxxxxxx' # please change to your API secret key. Find it in API secret key pairregion = u'gz'endpoint = 'https://cmq-queue-gz.api.qcloud.com'my_account = Account (endpoint, secretId, secretKey) my_account.set_log_level (logging.INFO) queue_name =' testq'my_queue = my_account.get_queue (queue_name) test_url_list = ["http://www.baidu.com"," http://www.qq.com", "http://cloud.tencent.com", "http://unkownurl.com"]def test_url (url_list): errorinfo = [] for url in url_list: resp = None try: resp = requests.get (url,timeout=3) except (requests.exceptions.Timeout, requests.exceptions.ConnectionError Requests.exceptions.ConnectTimeout) as e: logger.warn ("request exceptions:" + str (e)) errorinfo.append ("Access" + url + "timeout") else: if resp.status_code > = 400: logger.warn ("response status code fail:" + str (resp.status_code)) errorinfo.append ("Access" + url + "fail" Status code: "+ str (resp.status_code)) if len (errorinfo)! = 0: send_msg (" dial test exception notification: "+"\ r\ n ".join (errorinfo)) def send_msg (msg_body): try: logger.info (" send msg "+ msg_body) msg = Message (msg_body) ret_msg = my_queue.send_message (msg) except CMQExceptionBase As e: logger.warn ("Send msg to queue Fail! Exception:%s\ n "% e) raise edef main_handler (event, context): test_url (test_url_list) return" finish "

Use this code to create a function, and bind the requests-lib and cmq-lib layers in the layer management of the function. Because there are no duplicates between the two layers, they can be bound in any order.

After the binding is completed, you can trigger the function directly through the console to view the operation. When everything is normal, you can see the dialing process, as well as the record of the message sent to the message queue. At the same time, you can also go to the corresponding queue of the message queue and obtain the message record sent to it by obtaining the message.

As you can see from this example, the requests library and cmq's sdk are applied in the function code, but it is not packaged and uploaded with the function, but the dependent library is placed in the layer and referenced through the binding relationship. In this way, the next time we start a new function, we also need to use the requests library, which can be directly bound to the existing layer, without the need to package and upload again. The function code is only a file, does not need to have a large dependent library, but also can reduce the package size when uploading each update, or even directly and quickly use WebIDE to edit it.

The function of the layer provides a new storage scheme for dependent libraries and static files that are not often modified, and the divestiture of functions enables this kind of files to be reused and versioned. With the development of layer features, Tencent Cloud Serverless team will further expand the use of layer features, including automated layer creation and binding in development tools, layer sharing, providing a common layer for direct reuse, and so on. All of them have been implemented in roadmap and will be gradually implemented in the next development, making the development experience of cloud functions more convenient.

The above is how to use Layer in the cloud function SCF to achieve easy deployment. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.