Install third-party dependencies - Function Management| Alibaba Cloud Documentation Center

Third-party dependencies are often used for function execution. Usually, you can use some common built-in dependencies in the runtime environments of Function Compute.

For the built-in dependencies of each runtime environment, refer to:

To use a custom dependent module, you can package the dependent module and the function code together and upload the package to Function Compute.This topic describes how to install a third-party dependent module for a function.

Packaging requirements

When a function requires a third-party dependency, you must download the dependency to the folder where the function code is stored, package all dependencies and code together, and upload the entire package to Function Compute. Specify the code package when you create a function. You can use Fun or the Function Compute console to directly upload the package to Function Compute. Alternatively, you can upload the package to OSS and import the package to Function Compute from OSS.

During the upload, you can upload a zip package or specify the function folder. Then, Function Compute automatically zips the folder in the background.

Note that if you upload a zip package:

You must package all files, instead of only the code folders. Additionally, make sure that the handler function is in the root folder of the package.

In the Windows operating system, you can select all files in the function code folder, right-click these files, and compress them into a zip package.
In the Linux operating system, you can specify all files in the code folder as source files and run the zip command to generate a code package, such as zip code.zip /home/code/*.

Packaging example

Consider the following two points:

You must download the dependencies to the folder where the function is stored.
You must package all the files instead of only the code folders.

You can use the Function Compute console to upload a code package. On the code execution page, you can select Import from OSS, Upload Zip File, or Upload Folder. For the Windows operating system, we recommend that you use the Function Compute console to upload a package.

Use Fun to upload a code package.

Node.js packaging example

Package a third-party dependency mysql

The following steps describe how to use Fun to add a mysql module to access MySQL. For the installation guide of Fun, see here.

Create a folder to store code and dependent modules:
```
 mkdir /tmp/code
```
Install dependencies in the /tmp/code folder.
```
 cd /tmp/code
 npm install mysql
```

Create a new code file, such as /tmp/code/index.js, and use the mysql module in the code:

 var mysql = require('mysql');
  exports.handler = function(event, context, callback) {
      var connection = mysql.createConnection({
        host     : 'localhost',
        user     : 'me',
        password : 'secret',
        database : 'my_db'
      });
      connection.connect();
      connection.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
        if (error) return callback(error);
        console.log('The solution is: ', results[0].solution);
        callback(null, results[0].solution);
      });
      connection.end();
  };

Create a template.yml file, such as /tmp/code/template.yml, and enter the content as follows:

 ROSTemplateFormatVersion: '2015-09-01'
 Transform: 'Aliyun::Serverless-2018-04-03'
 Resources:
     FunDemo: 
       Type: 'Aliyun::Serverless::Service'
       nodejsdemo: 
         Type: 'Aliyun::Serverless::Function'
         Properties:
           Handler: index.handler
           Runtime: nodejs8
           CodeUri: './'

The description of the template.yml file is as follows: Declare a FunDemo service and a nodejsdemo function for the FunDemo service. Then, configure the function handler as index.handler and specify the function runtime environment as nodejs8. In addition, specify the CodeUri property as the current folder. Fun packages and uploads the folder or files that the CodeUri property specifies during the deployment. For more configuration rules, see here.

After the installation, the content of the /tmp/code folder is as follows:

 ls -l /tmp/code
 -rw-r--r--   1 tan  wheel   522B Jun 18 14:50 index.js
 drwxr-xr-x  13 tan  wheel   416B Jun 18 14:49 node_modules
 -rw-r--r--   1 tan  wheel   297B Jun 18 14:58 template.yml

Use Fun to deploy:
```
 fun deploy
```
Related logs appear as follows when you successfully run the fun deploy command:
```
 using region: cn-hangzhou
 using accountId: ***********3557
 using accessKeyId: ***********r3Ra
 using timeout: 300
 Waiting for service FunDemo to be deployed...
       Waiting for function nodejsdemo to be deployed...
           Waiting for packaging function nodejs code...
           package function nodejs code done
       function nodejsdemo deploy success
 service FunDemo deploy success
```
Log on to the console. You can see the related services and functions that are successfully created. The execution of functions can be triggered to return correct results.

Here is a brief description about what the fun deploy command does: When you use the fun deploy command, it creates a FunDemo service according to the configuration of the template.yml file. In addition, it creates a nodejsdemo function with a runtime environment nodejs8. Then, the nodejsdemo function packages and uploads the current folder that the CodeUri property specifies to Function Compute as the function code. The packaged code contains the node_modules folder that includes all the installed packages, so Function Compute can directly use these packages.

Call executable files

The functions may use some tools that are not written in Node.js, such as shell scripts or executable files that are complied in C++ or Go. However, you can still package those tools and the code together and use them by running external commands in functions.

For example, if you run a shell script script.sh, you can package it into the code folder and run the process.env ['FC _ FUNC_CODE_PATH ']command to retrieve the path of the current code.

The following example demonstrates how to run a shell script:

var exec = require('child_process');
exports.handler = function (event, context, callback) {
      var scriptPath = process.env['FC_FUNC_CODE_PATH'] + '/script.sh';
      exec.exec('bash ' + scriptPath, {}, function (err, stdout, stderr) {
          if (err) return callback(err);
          console.log(stdout, stderr);
          callback(null, stdout);
      });
};

Executable files that are compiled in C, C++, or Go must be compatible with the runtime environment of Function Compute. The Node.js runtime environment of Function Compute is:

Linux kernel version: Linux 4.4.24-2.al7.x86_64
Docker base image: Docker Pull Node:6.10

Python packing example

To use custom modules, you need to pack them and code files together. The following steps describe how to use Fun to add a PyMySQL module to access MySQL:

Create a folder to store code and dependent modules:
```
 mkdir /tmp/code
```

Create a new code file, such as /tmp/code/index.py , and use the pymysql module in the code:

 import pymysql.cursors
 # Connect to the database
 connection = pymysql.connect(host='localhost',
                                user='user',
                                password='passwd',
                                db='db',
                                charset='utf8mb4',
                                cursorclass=pymysql.cursors.DictCursor)
 def handler(event, context):
       with connection.cursor() as cursor:
           # Read a single record
           sql = "SELECT count(*) FROM `users`"
           cursor.execute(sql)
           result = cursor.fetchone()
           print(result)
           return result

Create a template.yml file, such as /tmp/code/template.yml, and enter the content as follows:

 ROSTemplateFormatVersion: '2015-09-01'
 Transform: 'Aliyun::Serverless-2018-04-03'
 Resources:
     FunDemo: 
       Type: 'Aliyun::Serverless::Service'
       pythondemo: 
         Type: 'Aliyun::Serverless::Function'
         Properties:
           Handler: index.handler
           Runtime: python3
           CodeUri: '. /'

Install dependencies in the /tmp/code folder.

Note that you cannot install the PyMySQL by using the pip install PyMySQL command. Otherwise, dependencies are scattered in many directories during the installation. You can download the dependent library files to the current folder so that you can zip them and upload the package.

If you do not use a Docker environment or the dynamic library in .so format, or do not compile binary programs, to only install language dependencies, you can run the command pip install -t . PyMySQL to install. This way to install PyMySQL increases the size of the code package, because the Python libraries are downloaded regardless of whether they have been installed.

If you use the Docker environment, we recommend that you use Fun to install third-party libraries, to debug locally, and to publish functions. Note that for the Windows operating system, use Docker for Windows. This prevents problems caused by inconsistencies between the development environment and the runtime environment. Particularly, when the function depends on binary and dynamic library files, you must use Fun to compile relevant dependencies.

Using Fun to install PyMySQL is simple. You only need to run the command in the project folder. The following example demonstrates how to install PyMySQL in the /tmp/code folder:
```
 fun install --runtime python3 --package-type pip PyMySQL
```
Notes for using Fun:
1. Install Docker to run Fun commands. For more information about how to install Docker, see Related documents.
2. Images that you require for running Fun are stored in Docker’s official repositories. Accessing these repositories can be slow. We recommend that you use Alibaba Cloud Container Registry. For more information, see Related documents.
3. Only root users can run Docker in the Linux operating system. Therefore, run the sudo command to enable command line tools. Alternatively, you can manage Docker as a non-root user according to Related documents.
After the installation, the content of the /tmp/code folder is as follows:
```
 $ ls -al  /tmp/code
 drwxr-xr-x   3 tan   wheel   96 Jun 18 17:08 .fun
 -rw-r--r--   1 tan   wheel  560 Jun 18 16:13 index.py
```
The .fun folder is where the installed dependencies of PyMySQL are.

If a problem occurs during the installation, you can specify the -v parameter to view more detailed logs:
```
 $ fun install -v --runtime python3 --package-type pip PyMySQL
 skip pulling image aliyunfc/runtime-python3.6:build-1.5.3...
 Task => [UNNAMED]
 => PYTHONUSERBASE=/code/.fun/python pip install --user PyMySQL
 Looking in indexes: http://mirrors.aliyun.com/pypi/simple/
 Collecting PyMySQL
 Downloading http://mirrors.aliyun.com/pypi/packages/ed/39/15045ae46f2a123019aa968dfcba0396c161c20f855f11dea6796bcaae95/PyMySQL-0.9.3-py2.py3-none-any.whl (47kB)
 Installing collected packages: PyMySQL
 Successfully installed PyMySQL-0.9.3
```
For more information about the fun install command, see this topic.
Use Fun to deploy
```
 fun deploy
```
Note: You can use the fun install command to install the dynamic library in .so format. The following example demonstrates how to use the fun install command to install the libzbar0 file:
```
 fun install --runtime python3 --package-type apt libzbar0
```
The dependencies are installed into the .fun folder after you run the command. You can use Fun to debug and deploy locally.

Note: Because dependencies are installed in the .fun folder, you must make sure that the CodeUri property in the template.yml file includes this folder, and it must be a top-level subfolder.

Run external commands

The functions may use some tools that are not written in Python, such as shell scripts or executable files that are complied in C++ or Go. However, you can still package those tools and the code together and use them by running external commands in functions.

For example, if you run a script.sh shell script, you can package it into the code folder and run the process.env ['FC _ FUNC_CODE_PATH '] command to get the path of the current folder.

The following example demonstrates how to run a shell script:

import os
import subprocess
def my_handler(event, context):
    script_path = os.environ.get('FC_FUNC_CODE_PATH') + '/script.sh'
    ret = subprocess.check_output(['bash', script_path])
    return ret

Executable files that are compiled in C, C++, or Go must be compatible with the runtime environment of Function Compute. The following Python runtime environments are supported in Function Compute:

Linux kernel version: Linux 4.4.24-2.al7.x86_64
Docker base image: Docker Pull Python:2.7; Docker Pull Python:3.6

PHP packaging example

The following steps demonstrate how to use Fun to install a Humble HTTP request library package request:

Create a folder to store code and dependent modules:
```
 mkdir /tmp/code
```

Create a code file, such as /tmp/code/index.php. Then, use the custom package requests in the code.

 <?php
 require_once __DIR__ . "/vendor/autoload.php";
 function handler($event, $context){
     $headers = array('Accept' => 'application/json');
     $options = array('auth' => array('user', 'pass'));
     $request = Requests::get('https://www.baidu.com', $headers, $options);
     var_dump($request->status_code);
     // int(200)
     var_dump($request->headers['content-type']);
     // string(31) "application/json; charset=utf-8"
     var_dump($request->body);
     // string(26891) "[...]"
 }

Install dependencies in the /tmp/code folder.

Create a file named composer.json

{
  "require": {
      "rmccue/requests": ">=1.0"
  }
}

Run the composer install --no-dev command to install dependencies.
```
cd /tmp/code
composer install --no-dev
```

After the installation, the content of the /tmp/code folder is as follows:

ls -l /tmp/code
-rw-r--r--  1 rsong  staff    72  8 22 09:54 composer.json
-rw-r--r--  1 rsong  staff  2165  8 22 09:54 composer.lock
-rw-r--r--  1 rsong  staff   523  8 22 09:54 index.php
drwxr-xr-x  5 rsong  staff   160  8 22 09:54 vendor

Create a template.yml file and publish it.
- Create a template.yml file in the /tmp/code folder as follows.
```
ROSTemplateFormatVersion: '2015-09-01'
Transform: 'Aliyun::Serverless-2018-04-03'
Resources:
FunDemo: 
  Type: 'Aliyun::Serverless::Service'
  phpdemo: 
    Type: 'Aliyun::Serverless::Function'
    Properties:
      Handler: index.handler
      Runtime: php7.2
      CodeUri: './'
```
  The description of the template.yml file is as follows: Declare a FunDemo service and a phpdemo function for the FunDemo service. Then, configure the function handler as index.handler and specify the function runtime environment as nodejs8. In addition, specify the CodeUri property as the current folder. Fun packages and uploads the folder or files that the CodeUri property specifies during the deployment. For more configuration rules, see here.
- Run the fun deploy command for the release.
```
fun deploy
```
  Related logs appear as follows after the release:
```
using region: cn-hangzhou
using accountId: ***********3557
using accessKeyId: ***********r3Ra
using timeout: 300
Waiting for service FunDemo to be deployed...
   Waiting for function phpdemo to be deployed...
       Waiting for packaging function phpdemo code...
       package function phpdemo code done
   function phpdemo deploy success
service FunDemo deploy success
```
Log on to the console. You can see the related services and functions that are successfully created. The execution of functions can be triggered to return correct results.

Here is a brief description about what the fun deploy command does: When you use the fun deploy command, it creates a FunDemo service according to the configuration of the template.yml file. In addition, it creates a phpdemo function with a runtime environment php7.2. Then, the phpdemo function packages and uploads the current folder that the CodeUri property specifies to Function Compute as the function code. The packaged code contains the vendor folder that includes all the installed packages, so Function Compute can directly use these packages.

To create a custom package, see Use custom packages for PHP Runtime

Java packaging example

When you compile code in Java, you must zip the code and dependencies into a JAR package and upload the JAR package to Function Compute. When you use the package of dependencies, write the pom.xml file and zip it into the JAR package. You can use Maven or IDEA for the Java packaging.

Use Maven to package code

For example, use OSS Java SDKand add OSS Java SDK in the pom.xml file.

<dependencies>
   <dependency>
     <groupId>com.aliyun.fc.runtime</groupId>
     <artifactId>fc-java-core</artifactId>
     <version>1.0.0</version>
   </dependency>
   <dependency>
     <groupId>com.aliyun.oss</groupId>
     <artifactId>aliyun-sdk-oss</artifactId>
     <version>2.6.1</version>
   </dependency>
 </dependencies>

Add the maven-assembly-plugin plug-in to the pom.xml file to zip dependencies into the JAR package.

<build>
     <plugins>
         <plugin>
             <artifactId>maven-assembly-plugin</artifactId>
             <version>3.1.0</version>
             <configuration>
                 <descriptorRefs>
                     <descriptorRef>jar-with-dependencies</descriptorRef>
                 </descriptorRefs>
                 <appendAssemblyId>false</appendAssemblyId> <!-- this is used for not append id to the jar name -->
             </configuration>
             <executions>
                 <execution>
                     <id>make-assembly</id> <!-- this is used for inheritance merges -->
                     <phase>package</phase> <!-- bind to the packaging phase -->
                     <goals>
                         <goal>single</goal>
                     </goals>
                 </execution>
             </executions>
         </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
         </plugin>
     </plugins>
</build>

Use IDEA to package code

Project Struction > Artifacts > Add Jar > From Modules with Dependencies > Apply > OK
Build > Build Artifacts > Build
Refer to the IDEA official document Packaging a Module into a JAR File

(https://pitcures.oss-cn-hangzhou.aliyuncs.com/BlogPictures/%E7%94%A8%E6%88%B7%E6%8C%87%E5%8D%97/%E5%87%BD%E6%95%B0%E6%89%93%E5%8C%85/java1.png)(https://pitcures.oss-cn-hangzhou.aliyuncs.com/BlogPictures/%E7%94%A8%E6%88%B7%E6%8C%87%E5%8D%97/%E5%87%BD%E6%95%B0%E6%89%93%E5%8C%85/java2.png)(https://pitcures.oss-cn-hangzhou.aliyuncs.com/BlogPictures/%E7%94%A8%E6%88%B7%E6%8C%87%E5%8D%97/%E5%87%BD%E6%95%B0%E6%89%93%E5%8C%85/java3.png)