Empacotar e implantar código em um runtime e fazê-lo executar conforme o esperado - Function Compute: Central de Documentação do Alibaba Cloud

Escolha um método de implantação

Método	Mais indicado para	Requisitos
pip + upload via console	Dependências puramente Python (sem binários compilados)	Python 3, pip3
Serverless Devs + Docker	Dependências com extensões binárias (C/C++, cryptography, numpy, etc.)	Serverless Devs CLI, Docker

Se suas dependências incluírem arquivos binários compilados, use o método Serverless Devs. Arquivos binários compilados em macOS ou Windows são incompatíveis com o ambiente Linux do Function Compute.

Preparativos

Configure um diretório de código local e uma função de exemplo antes de prosseguir com qualquer um dos métodos.

Crie um diretório chamado mycode.
- Linux e macOS: mkdir -p /tmp/mycode
- Windows: Crie uma pasta chamada mycode

No diretório mycode, crie o arquivo index.py com o seguinte conteúdo:

from emoji import emojize

def handler(event, context):
    return emojize(":thumbs_up:")

Método 1: Usar pip e o console

Pré-requisitos

Antes de começar, verifique se você tem:

Python 3 instalado na máquina local, com permissão para executar pip3
Uma função Python criada no console do Function Compute. Para instruções de configuração, consulte Criar uma função de evento

Instale dependências e faça upload

Instale a dependência emoji no diretório mycode:
```
pip3 install emoji -t .
```
Execute este comando dentro do diretório mycode. A flag -t . instala o pacote no diretório atual em vez do site-packages global.
Empacote todos os arquivos de mycode em um arquivo ZIP.
- Linux e macOS: Acesse o diretório mycode e execute:
```
zip code.zip -r ./*
```
  Nota
  Nota: Verifique se você tem permissões de leitura e gravação no diretório.
- Windows: Selecione todos os arquivos no diretório mycode, clique com o botão direito e compacte-os em um arquivo .zip.
Faça o upload do arquivo ZIP no console do Function Compute:
1. Localize a função de destino e acesse a página Function Details.
2. Clique em Code.
3. Clique em Upload Code > Upload ZIP Package e selecione code.zip.
4. Clique em Save and Deploy.

Importante

O Function Compute roda em um ambiente Linux. Se a biblioteca emoji (ou qualquer outra dependência) contiver arquivos binários compilados, o pacote poderá falhar ao ser executado quando instalado no macOS ou Windows. Nesse caso, recomendamos usar o WebIDE para empacotar dependências de terceiros ou utilizar o Método 2 (Serverless Devs + Docker).

Método 2: Usar Serverless Devs e Docker

O Serverless Devs compila as dependências dentro de um container Docker compatível com o runtime Linux do Function Compute, garantindo a compatibilidade binária.

Pré-requisitos

Antes de começar, verifique se você tem:

Compilar e implantar

Acesse o diretório mycode:
```
cd /tmp/mycode
```

Crie o arquivo s.yaml com o seguinte conteúdo:

edition: 3.0.0
name: fcDeployApp
access: "default"

vars: # The global variables.
  region: "cn-hangzhou"

resources:
  hello_world:
    component: fc3 # The name of the component.
    props:
      region: ${vars.region}
      functionName: "emojipy"
      description: 'this is emoji'
      runtime: "python3"
      code: ./
      handler: index.handler
      memorySize: 128
      timeout: 30
      environmentVariables:
        PYTHONUSERBASE: /code/python  # Add environment variables to obtain dependencies.code.

A tabela a seguir descreve os principais arquivos deste projeto:

Arquivo	Finalidade	Obrigatório
`s.yaml`	Configuração do projeto Serverless Devs	Sim
`index.py`	Código do handler da função	Sim
`requirements.txt`	Dependências Python a instalar	Sim

Crie o arquivo requirements.txt com o seguinte conteúdo:
```
emoji==2.0.0
```
Compile as dependências dentro de um container Docker:
```
sudo s build --use-docker
```
Após a conclusão da compilação, as dependências serão instaladas no diretório ./python.
Implante a função:
```
sudo s deploy
```
Após a implantação, a função estará disponível no Function Compute.

Próximos passos

Use camadas do Function Compute para compartilhar dependências entre várias funções sem precisar incluí-las em cada pacote de código: