As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Instalar Kernels e bibliotecas adicionais
Quando você cria um cluster JupyterHub no Amazon EMR, o kernel Python 3 padrão para Jupyter junto com os kernels Spark para Sparkmagic são instalados no PySpark contêiner Docker. Você pode instalar kernels adicionais. Você também pode instalar bibliotecas e pacotes adicionais e importá-los para o shell apropriado.
## Instalar um Kernel
Os kernels são instalados no contêiner Docker. A maneira mais fácil de fazer isso é criar um script bash com comandos de instalação, salvá-lo no nó principal e, em seguida, usar o comando `sudo docker exec jupyterhub script_name` para executar o script dentro do contêiner `jupyterhub`. O script de exemplo a seguir instala o kernel e, em seguida, instala algumas bibliotecas para esse kernel no nó principal, para que mais tarde você possa importar as bibliotecas usando o kernel no Jupyter.
```
#!/bin/bash
# Install Python 2 kernel
conda create -n py27 python=2.7 anaconda
source /opt/conda/envs/py27/bin/activate
apt-get update
apt-get install -y gcc
/opt/conda/envs/py27/bin/python -m pip install --upgrade ipykernel
/opt/conda/envs/py27/bin/python -m ipykernel install
# Install libraries for Python 2
/opt/conda/envs/py27/bin/pip install paramiko nltk scipy numpy scikit-learn pandas
```
Para instalar o kernel e as bibliotecas dentro do contêiner, abra uma conexão de terminal com o nó principal, salve o script em `/etc/jupyter/install_kernels.sh` e execute o seguinte comando na linha de comando do nó principal:
```
sudo docker exec jupyterhub bash /etc/jupyter/install_kernels.sh
```
## Usar bibliotecas e instalar bibliotecas adicionais
Um conjunto básico de bibliotecas de aprendizado de máquina e ciência de dados para Python 3 está pré-instalado no JupyterHub Amazon EMR. Você pode usar o `sudo docker exec jupyterhub bash -c "conda list" ` e o `sudo docker exec jupyterhub bash -c "pip freeze"`.
Se um job Spark precisar de bibliotecas nos nós de operador, recomendamos que você use uma ação de bootstrap para executar um script para instalar as bibliotecas ao criar o cluster. As ações de bootstrap são executadas em todos os nós do cluster durante o processo de criação do cluster, o que simplifica a instalação. Se você instalar bibliotecas em nós core/de operador depois que um cluster estiver em execução, a operação será mais complexa. Nós fornecemos um exemplo de programa em Python nesta seção que mostra como instalar essas bibliotecas.
A ação de bootstrap e os exemplos de programas em Python mostrados nesta seção usam um script bash salvo no Amazon S3 para instalar as bibliotecas em todos os nós.
O script referenciado nos exemplos a seguir usa `pip` para instalar paramiko, nltk, scipy, scikit-learn e pandas para o kernel do Python 3:
```
#!/bin/bash
sudo python3 -m pip install boto3 paramiko nltk scipy scikit-learn pandas
```
Depois de criar o script, carregue-o em um local no Amazon S3, por exemplo, `s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh`. Para obter mais informações, consulte [Carregar objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service* para que você possa usá-lo na sua ação de bootstrap ou no seu programa do Python.
**Para especificar uma ação de bootstrap que instala bibliotecas em todos os nós ao criar um cluster usando o AWS CLI**
1. Crie um script semelhante ao do exemplo anterior e salve-o em um local no Amazon S3. Nós usamos o exemplo `s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh`.
1. Crie o cluster com JupyterHub e use o `Path` argumento da `--bootstrap-actions` opção para especificar a localização do script, conforme mostrado no exemplo a seguir:
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name="MyJupyterHubCluster" --release-label emr-5.36.2 \
--applications Name=JupyterHub --log-uri s3://amzn-s3-demo-bucket/MyJupyterClusterLogs \
--use-default-roles --instance-type m5.xlarge --instance-count 2 --ec2-attributes KeyName=MyKeyPair \
--bootstrap-actions Path=s3://amzn-s3-demo-bucket/install-my-jupyter-libraries.sh,Name=InstallJupyterLibs
```
**Como especificar uma ação de bootstrap que instala bibliotecas em todos os nós ao criar um cluster usando o console**
1. Navegue até o novo console do Amazon EMR e selecione **Alternar para o console antigo** na navegação lateral. Para obter mais informações sobre o que esperar ao alternar para o console antigo, consulte [Usar o console antigo](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Escolha **Create cluster (Criar cluster)**, **Go to advanced options (Ir para opções avançadas)**.
1. Especifique as configurações para **Software and Steps (Software e etapas)** e **Hardware** conforme apropriado para seu aplicativo.
1. Na tela **General Cluster Settings (Configurações gerais de cluster)**, expanda **Bootstrap Actions (Ações de bootstrap)**.
1. Para **Add bootstrap action (Adicionar ação de bootstrap)**, selecione **Custom action (Ação personalizada)**, **Configure and add (Configurar e adicionar)**.
1. Em **Nome**, insira um nome fácil de lembrar. Em **Localização do script**, insira a localização do seu script no Amazon S3 (o exemplo que usamos é *s3://amzn-s3-demo-bucket/ install-my-jupyter-libraries .sh*). Deixe **Optional arguments (Argumentos opcionais)** em branco e escolha **Add (Adicionar)**.
1. Especifique outras configurações para o seu cluster e escolha **Next (Próximo)**.
1. Especifique as configurações de segurança e escolha **Create cluster (Criar cluster)**.
**Example Instalar bibliotecas em nós centrais de um cluster em execução**
Após instalar bibliotecas no nó principal de dentro do Jupyter, você pode instalar bibliotecas em nós core em execução de várias maneiras. O exemplo a seguir mostra um programa Python escrito para ser executado em uma máquina local. Quando você executa o programa Python localmente, ele usa o `AWS-RunShellScript` of AWS Systems Manager para executar o script de exemplo, mostrado anteriormente nesta seção, que instala bibliotecas nos nós principais do cluster.
```
import argparse
import time
import boto3
def install_libraries_on_core_nodes(cluster_id, script_path, emr_client, ssm_client):
"""
Copies and runs a shell script on the core nodes in the cluster.
:param cluster_id: The ID of the cluster.
:param script_path: The path to the script, typically an Amazon S3 object URL.
:param emr_client: The Boto3 Amazon EMR client.
:param ssm_client: The Boto3 AWS Systems Manager client.
"""
core_nodes = emr_client.list_instances(
ClusterId=cluster_id, InstanceGroupTypes=["CORE"]
)["Instances"]
core_instance_ids = [node["Ec2InstanceId"] for node in core_nodes]
print(f"Found core instances: {core_instance_ids}.")
commands = [
# Copy the shell script from Amazon S3 to each node instance.
f"aws s3 cp {script_path} /home/hadoop",
# Run the shell script to install libraries on each node instance.
"bash /home/hadoop/install_libraries.sh",
]
for command in commands:
print(f"Sending '{command}' to core instances...")
command_id = ssm_client.send_command(
InstanceIds=core_instance_ids,
DocumentName="AWS-RunShellScript",
Parameters={"commands": [command]},
TimeoutSeconds=3600,
)["Command"]["CommandId"]
while True:
# Verify the previous step succeeded before running the next step.
cmd_result = ssm_client.list_commands(CommandId=command_id)["Commands"][0]
if cmd_result["StatusDetails"] == "Success":
print(f"Command succeeded.")
break
elif cmd_result["StatusDetails"] in ["Pending", "InProgress"]:
print(f"Command status is {cmd_result['StatusDetails']}, waiting...")
time.sleep(10)
else:
print(f"Command status is {cmd_result['StatusDetails']}, quitting.")
raise RuntimeError(
f"Command {command} failed to run. "
f"Details: {cmd_result['StatusDetails']}"
)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("cluster_id", help="The ID of the cluster.")
parser.add_argument("script_path", help="The path to the script in Amazon S3.")
args = parser.parse_args()
emr_client = boto3.client("emr")
ssm_client = boto3.client("ssm")
install_libraries_on_core_nodes(
args.cluster_id, args.script_path, emr_client, ssm_client
)
if __name__ == "__main__":
main()
```