Creazione di un gruppo di sicurezza Creazione di un endpoint interattivo Scarica il server gateway URL Recupero del token di autenticazione Implementazione del notebook Pulizia

Uso di notebook Jupyter in hosting autonomo

Puoi ospitare e gestire Jupyter o JupyterLab notebook su un'istanza Amazon o sul tuo cluster EC2 EKS Amazon come notebook Jupyter con hosting autonomo. Puoi quindi eseguire carichi di lavoro interattivi con i notebook Jupyter in hosting autonomo. Le seguenti sezioni illustrano il processo di configurazione e distribuzione di un notebook Jupyter con hosting autonomo su un cluster Amazon. EKS

Creazione di un notebook Jupyter ospitato autonomamente su un cluster EKS

Creazione di un gruppo di sicurezza
Crea un Amazon EMR su endpoint EKS interattivo
Recupera il server gateway URL del tuo endpoint interattivo
Recupero di un token di autenticazione per la connessione all'endpoint interattivo
Esempio: implementa un notebook JupyterLab
Eliminazione di un notebook Jupyter in hosting autonomo

Creazione di un gruppo di sicurezza

Prima di poter creare un endpoint interattivo ed eseguire un Jupyter o un notebook ospitato autonomamente, è necessario creare un gruppo di sicurezza per controllare il traffico tra il JupyterLab notebook e l'endpoint interattivo. Per utilizzare la EC2 console Amazon o Amazon EC2 SDK per creare il gruppo di sicurezza, consulta la procedura descritta in Creare un gruppo di sicurezza nella Amazon EC2 User Guide. È necessario creare il gruppo di sicurezza nel VPC luogo in cui si desidera installare il server notebook.

Per seguire l'esempio di questa guida, usa lo VPC stesso del tuo EKS cluster Amazon. Se desideri ospitare il tuo notebook in un cluster diverso da VPC quello VPC per il tuo EKS cluster Amazon, potresti dover creare una connessione peering tra i dueVPCs. Per i passaggi per creare una connessione peering tra dueVPCs, consulta Creare una connessione VPC peering nella Amazon VPC Getting Started Guide.

È necessario l'ID del gruppo di sicurezza per creare un endpoint Amazon EMR su EKS interattivo nella fase successiva.

Crea un Amazon EMR su endpoint EKS interattivo

Dopo aver creato un gruppo di sicurezza per il notebook, utilizza le fasi indicate in Creazione di un endpoint interattivo per il cluster virtuale per creare un endpoint interattivo. È necessario fornire l'ID del gruppo di sicurezza che hai creato per il notebook in Creazione di un gruppo di sicurezza.

Inserisci l'ID di sicurezza al posto di your-notebook-security-group-id nella seguente configurazione sovrascrivi le impostazioni:


--configuration-overrides '{
    "applicationConfiguration": [
        {
            "classification": "endpoint-configuration",
            "properties": {
                "notebook-security-group-id": "your-notebook-security-group-id"
            }
        }
    ],
    "monitoringConfiguration": {
    ...'

Recupera il server gateway URL del tuo endpoint interattivo

Dopo aver creato un endpoint interattivo, recuperate il server gateway URL con il describe-managed-endpoint comando contenuto in. AWS CLIÈ necessario URL per connettere il notebook all'endpoint. Il server gateway URL è un endpoint privato.


aws emr-containers describe-managed-endpoint \
--region region \
--virtual-cluster-id virtualClusterId \
--id endpointId

Inizialmente, l'endpoint si trova nello stato CREATING. Dopo alcuni minuti, passa allo stato ACTIVE. Quando è nello stato ACTIVE, l'endpoint è pronto per l'uso.

Prendi nota dell'attributo serverUrl che il comando aws emr-containers describe-managed-endpoint restituisce dall'endpoint attivo. È necessario URL per connettere il notebook all'endpoint quando si implementa un Jupyter o un notebook ospitato autonomamente. JupyterLab

Recupero di un token di autenticazione per la connessione all'endpoint interattivo

Per connettersi a un endpoint interattivo da un Jupyter o un JupyterLab notebook, è necessario generare un token di sessione con. GetManagedEndpointSessionCredentials API Il un token funge da prova di autenticazione per connetterti al server dell'endpoint interattivo.

Il comando seguente viene spiegato più nel dettaglio di seguito con un esempio di output.


aws emr-containers get-managed-endpoint-session-credentials \
--endpoint-identifier endpointArn \
--virtual-cluster-identifier virtualClusterArn \
--execution-role-arn executionRoleArn \
--credential-type "TOKEN" \
--duration-in-seconds durationInSeconds \
--region region

endpointArn: Il ARN tuo endpoint. Puoi trovarlo ARN nel risultato di una describe-managed-endpoint chiamata.
virtualClusterArn: Il ARN del cluster virtuale.
executionRoleArn: Il ruolo ARN di esecuzione.
durationInSeconds: La durata in secondi per la quale il token è valido. La durata predefinita è 15 minuti (900) e il massimo è 12 ore (43200).
region: La stessa regione dell'endpoint.

L'output dovrebbe essere simile all'esempio seguente. Prendi nota del session-token valore che utilizzerai quando installerai un Jupyter o un notebook ospitato autonomamente. JupyterLab


{
    "id": "credentialsId",
    "credentials": {
        "token": "session-token"
    },
    "expiresAt": "2022-07-05T17:49:38Z"
}

Esempio: implementa un notebook JupyterLab

Una volta completati i passaggi precedenti, puoi provare questa procedura di esempio per distribuire un JupyterLab notebook nel EKS cluster Amazon con il tuo endpoint interattivo.

Crea uno spazio dei nomi per eseguire il server notebook.

Crea un file localmente, notebook.yaml, con i contenuti seguenti. I contenuti del file sono descritti di seguito.


apiVersion: v1
kind: Pod
metadata:
  name: jupyter-notebook
  namespace: namespace
spec:
  containers:
  - name: minimal-notebook
    image: jupyter/all-spark-notebook:lab-3.1.4 # open source image 
    ports:
    - containerPort: 8888
    command: ["start-notebook.sh"]
    args: ["--LabApp.token=''"]
    env:
    - name: JUPYTER_ENABLE_LAB
      value: "yes"
    - name: KERNEL_LAUNCH_TIMEOUT
      value: "400"
    - name: JUPYTER_GATEWAY_URL
      value: "serverUrl"
    - name: JUPYTER_GATEWAY_VALIDATE_CERT
      value: "false"
    - name: JUPYTER_GATEWAY_AUTH_TOKEN
      value: "session-token"

Se stai implementando un notebook Jupyter su un cluster solo per Fargate, etichetta il pod di Jupyter con un'etichetta role come mostrato nell'esempio seguente:


...
metadata:
  name: jupyter-notebook
  namespace: default
  labels:
    role: example-role-name-label
spec:
            ...

namespace

Lo spazio dei nomi Kubernetes in cui viene implementato il notebook.

serverUrl

L'attributo serverUrl che il comando describe-managed-endpoint ha restituito in Recupera il server gateway URL del tuo endpoint interattivo .

session-token

L'attributo session-token che il comando get-managed-endpoint-session-credentials ha restituito in Recupero di un token di autenticazione per la connessione all'endpoint interattivo.

KERNEL_LAUNCH_TIMEOUT

La quantità di tempo espressa in secondi per cui l'endpoint interattivo attende che il kernel raggiunga lo stato RUNNING. Garantisci un tempo sufficiente per il completamento dell'avvio del kernel impostando il timeout di avvio del kernel su un valore appropriato (massimo 400 secondi).

KERNEL_EXTRA_SPARK_OPTS

Facoltativamente, puoi trasmettere configurazioni Spark aggiuntive per i kernel Spark. Imposta questa variabile di ambiente con i valori come proprietà di configurazione Spark, come mostrato nell'esempio seguente:


- name: KERNEL_EXTRA_SPARK_OPTS
  value: "--conf spark.driver.cores=2
          --conf spark.driver.memory=2G
          --conf spark.executor.instances=2
          --conf spark.executor.cores=2
          --conf spark.executor.memory=2G
          --conf spark.dynamicAllocation.enabled=true
          --conf spark.dynamicAllocation.shuffleTracking.enabled=true
          --conf spark.dynamicAllocation.minExecutors=1
          --conf spark.dynamicAllocation.maxExecutors=5
          --conf spark.dynamicAllocation.initialExecutors=1
          "

Implementa le specifiche del pod nel tuo cluster AmazonEKS:
```
kubectl apply -f notebook.yaml -n namespace
```
Questo avvierà un JupyterLab notebook minimale collegato al tuo Amazon EMR su un endpoint EKS interattivo. Attendi che il pod raggiunga lo stato RUNNING. Puoi verificarne lo stato con il comando seguente:
```
kubectl get pod jupyter-notebook -n namespace
```
Quando il pod è pronto, il get pod comando restituisce un output simile a questo:
```
NAME              READY  STATUS   RESTARTS  AGE
jupyter-notebook  1/1    Running  0         46s
```
Collega il gruppo di sicurezza del notebook al nodo in cui il notebook è pianificato.
1. Per prima cosa, identifica il nodo in cui il pod jupyter-notebook è pianificato con il comando describe pod.
```
kubectl describe pod jupyter-notebook -n namespace
```
2. Apri la EKS console Amazon a https://console.aws.amazon.com/eks/home#/clusters.
3. Vai alla scheda Compute per il tuo EKS cluster Amazon e seleziona il nodo identificato dal describe pod comando. Seleziona l'ID dell'istanza per il nodo.
4. Nel menu Azioni, seleziona Sicurezza > Modifica gruppi di sicurezza per allegare il gruppo di sicurezza creato in Creazione di un gruppo di sicurezza.
5. Se stai implementando il pod per notebook Jupyter su AWS Fargate, crea un pod SecurityGroupPolicyda applicare al notebook Jupyter con l'etichetta del ruolo:
```
cat >my-security-group-policy.yaml <<EOF
apiVersion: vpcresources.k8s.aws/v1beta1
kind: SecurityGroupPolicy
metadata:
  name: example-security-group-policy-name
  namespace: default
spec:
  podSelector:
    matchLabels:
      role: example-role-name-label
  securityGroups:
    groupIds:
      - your-notebook-security-group-id
EOF
```
Ora esegui il port-forward in modo da poter accedere localmente all'interfaccia: JupyterLab
```
kubectl port-forward jupyter-notebook 8888:8888 -n namespace
```
Una volta che è in esecuzione, accedi al tuo browser locale e visita localhost:8888 per vedere l' JupyterLab interfaccia:

Da JupyterLab, crea un nuovo taccuino Scala. Ecco un frammento di codice di esempio che puoi eseguire per approssimare il valore di Pi:


import scala.math.random
import org.apache.spark.sql.SparkSession

/** Computes an approximation to pi */
val session = SparkSession
  .builder
  .appName("Spark Pi")
  .getOrCreate()

val slices = 2
// avoid overflow
val n = math.min(100000L * slices, Int.MaxValue).toInt 
 
val count = session.sparkContext
.parallelize(1 until n, slices)
.map { i =>
  val x = random * 2 - 1
  val y = random * 2 - 1
  if (x*x + y*y <= 1) 1 else 0
}.reduce(_ + _)

println(s"Pi is roughly ${4.0 * count / (n - 1)}")
session.stop()

Schermata di esempio del codice del notebook Scala in JupyterLab.

Eliminazione di un notebook Jupyter in hosting autonomo

Quando è il momento di eliminare il notebook in hosting autonomo, puoi eliminare anche l'endpoint interattivo e il gruppo di sicurezza. Esegui le azioni nell'ordine seguente:

Utilizza il comando seguente per eliminare il pod jupyter-notebook:
```
kubectl delete pod jupyter-notebook -n namespace
```
Quindi, elimina l'endpoint interattivo con il comando delete-managed-endpoint. La procedura per l'eliminazione di un endpoint interattivo è riportata in Eliminazione di un endpoint interattivo. Inizialmente, l'endpoint si troverà nello stato TERMINATING. Una volta ripulite tutte le risorse, passa allo stato TERMINATED.
Se non intendi utilizzare il gruppo di sicurezza dei notebook che hai creato in Creazione di un gruppo di sicurezza per altre implementazioni di notebook Jupyter, puoi eliminarlo. Per ulteriori informazioni, consulta Eliminare un gruppo di sicurezza nella Amazon EC2 User Guide.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Monitoraggio degli endpoint interattivi

Altre operazioni