diff --git a/Instructions/Exercises/AI-01-Explore-LLMs.md b/Instructions/Exercises/AI-01-Explore-LLMs.md new file mode 100644 index 0000000..c0453c7 --- /dev/null +++ b/Instructions/Exercises/AI-01-Explore-LLMs.md @@ -0,0 +1,177 @@ +--- +lab: + title: Explorar modelos de linguagem grandes com o Azure Databricks +--- + +# Explorar modelos de linguagem grandes com o Azure Databricks + +Os LLMs (Modelos de linguagem grande) podem ser um ativo poderoso para tarefas de NLP (processamento de linguagem natural) quando integrados ao Azure Databricks e ao Hugging Face Transformers. O Azure Databricks fornece uma plataforma perfeita para acessar, ajustar e implantar LLMs, incluindo modelos pré-treinados da extensa biblioteca da Hugging Face. Para inferência de modelo, a classe pipelines da Hugging Face simplifica o uso de modelos pré-treinados, aceitando uma ampla variedade de tarefas de NLP diretamente no ambiente do Databricks. + +Este laboratório levará aproximadamente **30** minutos para ser concluído. + +## Antes de começar + +É necessário ter uma [assinatura do Azure](https://azure.microsoft.com/free) com acesso de nível administrativo. + +## Provisionar um workspace do Azure Databricks + +> **Dica**: Se você já tem um workspace do Azure Databricks, pode ignorar esse procedimento e usar o workspace existente. + +Este exercício inclui um script para provisionar um novo workspace do Azure Databricks. O script tenta criar um recurso de workspace do Azure Databricks de camada *Premium* em uma região na qual sua assinatura do Azure tenha cota suficiente para os núcleos de computação necessários para este exercício; e pressupõe que sua conta de usuário tenha permissões suficientes na assinatura para criar um recurso de workspace do Azure Databricks. Se o script falhar devido a cota ou permissões insuficientes, você pode tentar [criar um workspace do Azure Databricks interativamente no portal do Azure](https://learn.microsoft.com/azure/databricks/getting-started/#--create-an-azure-databricks-workspace). + +1. Em um navegador da web, faça logon no [portal do Azure](https://portal.azure.com) em `https://portal.azure.com`. + +2. Use o botão **[\>_]** à direita da barra de pesquisa na parte superior da página para criar um Cloud Shell no portal do Azure, selecionando um ambiente ***PowerShell*** e criando um armazenamento caso solicitado. O Cloud Shell fornece uma interface de linha de comando em um painel na parte inferior do portal do Azure, conforme mostrado aqui: + + ![Portal do Azure com um painel do Cloud Shell](./images/cloud-shell.png) + + > **Observação**: se você tiver criado anteriormente um cloud shell que usa um ambiente *Bash*, use o menu suspenso no canto superior esquerdo do painel do cloud shell para alterá-lo para ***PowerShell***. + +3. Observe que você pode redimensionar o Cloud Shell arrastando a barra do separador na parte superior do painel ou usando os ícones **—** , **◻** e **X** no canto superior direito do painel para minimizar, maximizar e fechar o painel. Para obter mais informações de como usar o Azure Cloud Shell, confira a [documentação do Azure Cloud Shell](https://docs.microsoft.com/azure/cloud-shell/overview). + +4. No painel do PowerShell, insira os seguintes comandos para clonar esse repositório: + + ```powershell + rm -r mslearn-databricks -f + git clone https://github.com/MicrosoftLearning/mslearn-databricks + ``` + +5. Depois que o repositório tiver sido clonado, insira o seguinte comando para executar **setup.ps1** do script, que provisiona um workspace do Azure Databricks em uma região disponível: + + ```powershell + ./mslearn-databricks/setup.ps1 + ``` + +6. Se solicitado, escolha qual assinatura você deseja usar (isso só acontecerá se você tiver acesso a várias assinaturas do Azure). + +7. Aguarde a conclusão do script - isso normalmente leva cerca de 5 minutos, mas em alguns casos pode levar mais tempo. Enquanto você aguarda, revise o artigo [Introdução ao Delta Lake](https://docs.microsoft.com/azure/databricks/delta/delta-intro) na documentação do Azure Databricks. + +## Criar um cluster + +O Azure Databricks é uma plataforma de processamento distribuído que usa *clusters* do Apache Spark para processar dados em paralelo em vários nós. Cada cluster consiste em um nó de driver para coordenar o trabalho e nós de trabalho para executar tarefas de processamento. Neste exercício, você criará um cluster de *nó único* para minimizar os recursos de computação usados no ambiente de laboratório (no qual os recursos podem ser restritos). Em um ambiente de produção, você normalmente criaria um cluster com vários nós de trabalho. + +> **Dica**: Se você já tiver um cluster com uma versão de runtime 13.3 LTS **ML** ou superior em seu workspace do Azure Databricks, poderá usá-lo para concluir este exercício e ignorar este procedimento. + +1. No portal do Azure, navegue até o grupo de recursos **msl-*xxxxxxx*** criado pelo script (ou o grupo de recursos que contém seu workspace do Azure Databricks existente) +1. Selecione o recurso Serviço do Azure Databricks (chamado **databricks-*xxxxxxx*** se você usou o script de instalação para criá-lo). +1. Na página **Visão geral** do seu workspace, use o botão **Iniciar workspace** para abrir seu workspace do Azure Databricks em uma nova guia do navegador, fazendo o logon se solicitado. + + > **Dica**: ao usar o portal do workspace do Databricks, várias dicas e notificações podem ser exibidas. Dispense-as e siga as instruções fornecidas para concluir as tarefas neste exercício. + +1. Na barra lateral à esquerda, selecione a tarefa **(+) Novo** e, em seguida, selecione **Cluster**. +1. Na página **Novo Cluster**, crie um novo cluster com as seguintes configurações: + - **Nome do cluster**: cluster *Nome do Usuário* (o nome do cluster padrão) + - **Política**: Sem restrições + - **Modo de cluster**: Nó Único + - **Modo de acesso**: Usuário único (*com sua conta de usuário selecionada*) + - **Versão do runtime do Databricks**: *Selecione a edição do **ML** da última versão não beta do runtime (**Não** uma versão de runtime Standard) que:* + - ***Não** usa uma GPU* + - *Inclui o Scala > **2.11*** + - *Inclui o Spark > **3.4*** + - **Usa a Aceleração do Photon**: Não selecionado + - **Tipo de nó**: Standard_DS3_v2 + - **Encerra após** *20* **minutos de inatividade** + +1. Aguarde a criação do cluster. Isso pode levar alguns minutos. + +> **Observação**: se o cluster não for iniciado, sua assinatura pode ter cota insuficiente na região onde seu workspace do Azure Databricks está provisionado. Consulte [Limite de núcleo da CPU impede a criação do cluster](https://docs.microsoft.com/azure/databricks/kb/clusters/azure-core-limit) para obter detalhes. Se isso acontecer, você pode tentar excluir seu workspace e criar um novo workspace em uma região diferente. Você pode especificar uma região como um parâmetro para o script de instalação da seguinte maneira: `./mslearn-databricks/setup.ps1 eastus` + +## Instalar as bibliotecas necessárias + +1. Na página do cluster, selecione a guia **Bibliotecas**. + +2. Selecione **Instalar novo**. + +3. Selecione **PyPI** como a origem da biblioteca e digite `transformers==4.44.0` no campo **pacote**. + +4. Selecione **Instalar**. + +## Carregar modelos pré-treinado + +1. No workspace do Databricks, vá para a seção **Espaço de trabalho**. + +2. Selecione **Criar** e, em seguida, selecione **Notebook**. + +3. Dê um nome ao notebook e selecione `Python` como a linguagem. + +4. Na primeira célula do código, insira e execute o código a seguir: + + ```python + from transformers import pipeline + + # Load the summarization model + summarizer = pipeline("summarization") + + # Load the sentiment analysis model + sentiment_analyzer = pipeline("sentiment-analysis") + + # Load the translation model + translator = pipeline("translation_en_to_fr") + + # Load a general purpose model for zero-shot classification and few-shot learning + classifier = pipeline("zero-shot-classification") + ``` +Isso carregará todos os modelos necessários para as tarefas de PNL apresentadas neste exercício. + +### Resumir texto + +Um pipeline de resumo gera resumos concisos de textos mais longos. Ao especificar um intervalo de comprimento (`min_length`, `max_length`) e se ele usará amostragem ou não (`do_sample`), podemos determinar o quão preciso ou criativo será o resumo gerado. + +1. Na nova célula de código, insira o código a seguir: + + ```python + text = "Large language models (LLMs) are advanced AI systems capable of understanding and generating human-like text by learning from vast datasets. These models, which include OpenAI's GPT series and Google's BERT, have transformed the field of natural language processing (NLP). They are designed to perform a wide range of tasks, from translation and summarization to question-answering and creative writing. The development of LLMs has been a significant milestone in AI, enabling machines to handle complex language tasks with increasing sophistication. As they evolve, LLMs continue to push the boundaries of what's possible in machine learning and artificial intelligence, offering exciting prospects for the future of technology." + summary = summarizer(text, max_length=75, min_length=25, do_sample=False) + print(summary) + ``` + +2. Execute a célula para ver o texto resumido. + +### Analisar sentimento + +O pipeline de análise de sentimento determina o sentimento de um determinado texto. Ele classifica o texto em categorias como positivo, negativo ou neutro. + +1. Na nova célula de código, insira o código a seguir: + + ```python + text = "I love using Azure Databricks for NLP tasks!" + sentiment = sentiment_analyzer(text) + print(sentiment) + ``` + +2. Execute a célula para ver o resultado da análise de sentimento. + +### Traduzir o texto + +O pipeline de tradução converte o texto de um idioma para outro. Neste exercício, a tarefa usada foi `translation_en_to_fr`, o que significa que ele traduzirá qualquer texto do inglês para o francês. + +1. Na nova célula de código, insira o código a seguir: + + ```python + text = "Hello, how are you?" + translation = translator(text) + print(translation) + ``` + +2. Execute a célula para ver o texto traduzido em francês. + +### Classificar textos + +O pipeline de classificação zero-shot permite que um modelo classifique o texto em categorias que não viu durante o treinamento. Portanto, requer rótulos predefinidos como um parâmetro `candidate_labels`. + +1. Na nova célula de código, insira o código a seguir: + + ```python + text = "Azure Databricks is a powerful platform for big data analytics." + labels = ["technology", "health", "finance"] + classification = classifier(text, candidate_labels=labels) + print(classification) + ``` + +2. Execute a célula para ver os resultados da classificação zero-shot. + +## Limpar + +No portal do Azure Databricks, na página **Computação**, selecione seu cluster e selecione **■ Terminar** para encerrar o processo. + +Se você tiver terminado de explorar o Azure Databricks, poderá excluir os recursos que criou para evitar custos desnecessários do Azure e liberar capacidade em sua assinatura. diff --git a/Instructions/Exercises/AI-02-RAG.md b/Instructions/Exercises/AI-02-RAG.md new file mode 100644 index 0000000..22f58a7 --- /dev/null +++ b/Instructions/Exercises/AI-02-RAG.md @@ -0,0 +1,179 @@ +# Exercício 02 – Geração Aumentada de Recuperação usando o Azure Databricks + +## Objetivo +Este exercício orienta você na configuração de um fluxo de trabalho de RAG (Geração Aumentada de Recuperação) no Azure Databricks. O processo envolve a ingestão de dados, a criação de incorporações vetoriais, o armazenamento dessas incorporações em um banco de dados vetorial e o uso delas para aumentar a entrada de um modelo generativo. + +## Requisitos +Uma assinatura ativa do Azure. Se você não tiver uma, poderá se inscrever para uma [avaliação gratuita](https://azure.microsoft.com/en-us/free/). + +## Tempo estimado: 40 minutos + +## Etapa 1: Provisionar o Azure Databricks +- Fazer logon no portal do Azure: + 1. Vá para o portal do Azure e entre com suas credenciais. +- Criar serviço do Databricks: + 1. Navegue até "Criar um recurso" > "Análise" > "Azure Databricks". + 2. Insira os detalhes necessários, como nome do espaço de trabalho, assinatura, grupo de recursos (crie um novo ou selecione um já existente) e local. + 3. Selecione o tipo de preço (escolha padrão para este laboratório). + 4. Clique em "Examinar + criar" e "Criar" depois que a validação for aprovada. + +## Etapa 2: Iniciar o espaço de trabalho e criar um cluster +- Iniciar o workspace do Databricks: + 1. Quando a implantação estiver concluída, vá para o recurso e clique em "Iniciar espaço de trabalho". +- Criar um Cluster do Spark: + 1. No workspace do Databricks, clique em "Computação" na barra lateral e, em seguida, em "Criar computação". + 2. Especifique o nome do cluster e selecione uma versão de runtime do Spark. + 3. Escolha o tipo de trabalhador como "Padrão" e o tipo de nó com base nas opções disponíveis (escolha nós menores para eficiência de custo). + 4. Clique em "Criar computação". + +## Etapa 3: Preparação de dados +- Ingerir Dados + 1. Baixe um conjunto de dados de amostra de artigos da Wikipédia [aqui](https://dumps.wikimedia.org/enwiki/latest/). + 2. Carregue o conjunto de dados no Azure Data Lake Storage ou diretamente no Sistema de Arquivos do Azure Databricks. + +- Carregar dados no Azure Databricks +```python +from pyspark.sql import SparkSession + +spark = SparkSession.builder.appName("RAG-DataPrep").getOrCreate() +raw_data_path = "/mnt/data/wiki_sample.json" # Adjust the path as necessary + +raw_df = spark.read.json(raw_data_path) +raw_df.show(5) +``` + +- Limpeza e pré-processamento de dados + 1. Limpe e pré-processe os dados para extrair campos de texto relevantes. + + ```python + from pyspark.sql.functions import col + + clean_df = raw_df.select(col("title"), col("text")) + clean_df = clean_df.na.drop() + clean_df.show(5) + ``` +## Etapa 4: Geração de incorporações +- Instalar bibliotecas necessárias + 1. Certifique-se de ter as bibliotecas de transformadores e transformadores de sentença instaladas. + + ```python + %pip install transformers sentence-transformers + ``` +- Gerar incorporações + 1. Use um modelo pré-treinado para gerar incorporações para o texto. + + ```python + from sentence_transformers import SentenceTransformer + + model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2') + + def embed_text(text): + return model.encode(text).tolist() + + # Apply the embedding function to the dataset + from pyspark.sql.functions import udf + from pyspark.sql.types import ArrayType, FloatType + + embed_udf = udf(embed_text, ArrayType(FloatType())) + embedded_df = clean_df.withColumn("embeddings", embed_udf(col("text"))) + embedded_df.show(5) + ``` + +## Etapa 5: Armazenamento de incorporações +- Armazenar incorporações em tabelas Delta + 1. Salve os dados incorporados em uma tabela Delta para recuperação eficiente. + + ```python + embedded_df.write.format("delta").mode("overwrite").save("/mnt/delta/wiki_embeddings") + ``` + + 2. Criar uma tabela Delta + + ```python + CREATE TABLE IF NOT EXISTS wiki_embeddings + LOCATION '/mnt/delta/wiki_embeddings' + ``` +## Etapa 6: Implementação da busca em vetores +- Configurar busca em vetores + 1. Use os recursos de busca em vetores do Databricks ou integre-se a um banco de dados vetorial como Milvus ou Pinecone. + + ```python + from databricks.feature_store import FeatureStoreClient + + fs = FeatureStoreClient() + + fs.create_table( + name="wiki_embeddings_vector_store", + primary_keys=["title"], + df=embedded_df, + description="Vector embeddings for Wikipedia articles." + ) + ``` +- Executar a busca em vetores + 1. Implemente uma função para pesquisar documentos relevantes com base em um vetor de consulta. + + ```python + def search_vectors(query_text, top_k=5): + query_embedding = model.encode([query_text]).tolist() + query_df = spark.createDataFrame([(query_text, query_embedding)], ["query_text", "query_embedding"]) + + results = fs.search_table( + name="wiki_embeddings_vector_store", + vector_column="embeddings", + query=query_df, + top_k=top_k + ) + return results + + query = "Machine learning applications" + search_results = search_vectors(query) + search_results.show() + ``` + +## Etapa 7: Aumento generativo +- Prompts de aumento com dados recuperados: + 1. Combine os dados recuperados com a consulta do usuário para criar um prompt avançado para o LLM. + + ```python + def augment_prompt(query_text): + search_results = search_vectors(query_text) + context = " ".join(search_results.select("text").rdd.flatMap(lambda x: x).collect()) + return f"Query: {query_text}\nContext: {context}" + + prompt = augment_prompt("Explain the significance of the Turing test") + print(prompt) + ``` + +- Gerar respostas com LLM: + 2. Use um LLM como GPT-3 ou modelos semelhantes da Hugging Face para gerar respostas. + + ```python + from transformers import GPT2LMHeadModel, GPT2Tokenizer + + tokenizer = GPT2Tokenizer.from_pretrained("gpt2") + model = GPT2LMHeadModel.from_pretrained("gpt2") + + inputs = tokenizer(prompt, return_tensors="pt") + outputs = model.generate(inputs["input_ids"], max_length=500, num_return_sequences=1) + response = tokenizer.decode(outputs[0], skip_special_tokens=True) + + print(response) + ``` + +## Etapa 8: Avaliação e otimização +- Avalie a qualidade das respostas geradas: + 1. Avalie a relevância, coerência e precisão das respostas geradas. + 2. Colete comentários do usuário e itere no processo de aumento de prompt. + +- Otimizar o fluxo de trabalho RAG: + 1. Experimente diferentes modelos de incorporação, tamanhos de partes e parâmetros de recuperação para otimizar o desempenho. + 2. Monitore o desempenho do sistema e faça ajustes para melhorar a precisão e a eficiência. + +## Etapa 9: Limpar os recursos +- Encerrar o cluster: + 1. Volte para a página "Computação", selecione seu cluster e clique em "Encerrar" para interromper o cluster. + +- Opcional: exclua o serviço Databricks: + 1. Para evitar cobranças adicionais, considere excluir o workspace do Databricks se esse laboratório não fizer parte de um projeto ou roteiro de aprendizagem maior. + +Seguindo estas etapas, você terá implementado um sistema RAG (Geração Aumentada de Recuperação) usando o Azure Databricks. Este laboratório demonstra como pré-processar dados, gerar incorporações, armazená-los com eficiência, realizar buscas em vetores e usar modelos generativos para criar respostas enriquecidas. A abordagem pode ser adaptada a vários domínios e conjuntos de dados para aprimorar os recursos dos aplicativos orientados por IA. \ No newline at end of file diff --git a/Instructions/Exercises/DE-04-Implement-CI-CD-pipeline.md b/Instructions/Exercises/DE-04-Implement-CI-CD-pipeline.md index a753975..f2ae858 100644 --- a/Instructions/Exercises/DE-04-Implement-CI-CD-pipeline.md +++ b/Instructions/Exercises/DE-04-Implement-CI-CD-pipeline.md @@ -5,11 +5,11 @@ lab: # Implementar fluxos de trabalho de CI/CD com o Azure Databricks -A implementação de pipelines de CI (Integração Contínua) e CD (Implantação Contínua) com o Azure Databricks e o Azure DevOps ou o Azure Databricks e o GitHub envolve a configuração de uma série de etapas automatizadas para garantir que as alterações de código sejam integradas, testadas e implantadas de modo eficiente. O processo normalmente inclui a conexão com um repositório Git, a execução de trabalhos usando o Azure Pipelines para compilar e testar o código, e implantar os artefatos de build para uso em notebooks do Databricks. Esse fluxo de trabalho permite um ciclo de desenvolvimento robusto, possibilitando a integração e a entrega contínuas alinhadas com as práticas modernas de DevOps. +A implementação de fluxos de trabalho de CI/CD com o GitHub Actions e o Azure Databricks pode simplificar seu processo de desenvolvimento e aprimorar a automação. O GitHub Actions fornece uma plataforma poderosa para automatizar fluxos de trabalho de software, incluindo integração contínua (CI) e entrega contínua (CD). Quando integrados ao Azure Databricks, esses fluxos de trabalho podem executar tarefas de dados complexas, como rodar notebooks ou implantar atualizações para os ambientes de Databricks. Por exemplo, você pode usar o GitHub Actions para automatizar a implantação de notebooks do Databricks, gerenciar uploads do sistema de arquivos do Databricks e configurar a CLI do Databricks em seus fluxos de trabalho. Essa integração facilita um ciclo de desenvolvimento mais eficiente e resistente a erros, especialmente para aplicações orientadas a dados. Este laboratório levará aproximadamente **40** minutos para ser concluído. ->**Observação:** você precisa de uma conta do Github e acesso ao Azure DevOps para concluir este exercício. +>**Observação:** você precisa de uma conta do Github para concluir este exercício. ## Provisionar um workspace do Azure Databricks @@ -89,141 +89,163 @@ O Azure Databricks é uma plataforma de processamento distribuído que usa *clus 3. Use a opção de menu **▸ Executar Célula** à esquerda da célula para executá-la. Em seguida, aguarde o término do trabalho do Spark executado pelo código. -## Configurar um repositório GitHub e um projeto do Azure DevOps +## Configurar um repositório do GitHub -Depois de conectar um repositório GitHub a um projeto do Azure DevOps, você pode configurar pipelines de CI que são disparados com todas as alterações feitas no repositório. +Depois de conectar um repositório GitHub a um espaço de trabalho do Azure Databricks, você pode configurar pipelines de CI/CD no GitHub Actions que são disparados com quaisquer alterações feitas no seu repositório. 1. Acesse sua [conta do GitHub](https://github.com/) e crie um novo repositório para seu projeto. 2. Clone o repositório em seu computador local usando `git clone`. -3. Baixe o [arquivo CSV](https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/sample_sales.csv) no repositório local e confirme as alterações. +3. Faça download dos arquivos necessários para este exercício em seu repositório local: + - [Arquivo CSV](https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/sample_sales.csv) + - [Databricks notebook](https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/sample_sales_notebook.dbc) + - [Arquivo de configuração do trabalho](https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/job-config.json): -4. Baixe o [notebook do Databricks](https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/sample_sales_notebook.dbc) que será usado para ler o arquivo CSV e executar a transformação de dados. Confirme as alterações. + Faça commit e efetue push das alterações. -5. Acesse o [portal do Azure DevOps](https://azure.microsoft.com/en-us/products/devops/) e crie um novo projeto. +## Configurar os segredos do repositório -6. No projeto do Azure DevOps, acesse a seção **Repos** e selecione **Importar** para conectá-lo ao repositório GitHub. +Segredos são variáveis que você cria em uma organização, repositório ou ambiente de repositório. Os segredos que você cria estão disponíveis para uso em fluxos de trabalho das GitHub Actions. O GitHub Actions só pode fazer a leitura de um segredo se você incluir explicitamente o segredo em um fluxo de trabalho. -7. Na barra do lado esquerdo, vá até **Configurações do projeto > Conexões de serviço**. +Como os fluxos de trabalho do GitHub Actions precisam acessar recursos do Azure Databricks, as credenciais de autenticação serão armazenadas como variáveis criptografadas a serem usadas com os pipelines de CI/CD. -8. Selecione **Criar conexão de serviço** e **Azure Resource Manager**. +Antes de criar segredos de repositório, você precisa gerar um token de acesso pessoal no Azure Databricks: -9. Em **Método de autenticação**, selecione **Federação de Identidade de carga de trabalho (automática)**. Selecione **Avançar**. +1. No espaço de trabalho do Azure Databricks, selecione seu nome de usuário do Azure Databricks na barra superior e selecione **Configurações** na lista suspensa. -10. Em **Nível do escopo**, selecione **Assinatura**. Selecione a assinatura e o grupo de recursos em que você criou o workspace do Databricks. +2. Selecione **Desenvolvedor**. -11. Insira um nome para sua conexão de serviço e marque a opção **Conceder permissão de acesso a todos os pipelines**. Selecione **Salvar**. +3. Ao lado de **Tokens de acesso**, selecione **Gerenciar**. -Agora seu projeto do [Azure] DevOps tem acesso ao workspace do Databricks e você pode conectá-lo aos pipelines. +4. Selecione **Gerar novo token** e escolha **Gerar**. -## Configurar um pipeline de CI +5. Copie o token exibido para um local seguro e selecione **Concluído**. -1. Na barra do lado esquerdo, vá até **Pipelines** e selecione **Criar pipeline**. +6. Agora, na página do repositório, selecione a guia **Configurações** . -2. Selecione o **GitHub** como fonte e selecione seu repositório. + ![Guia Configurações do GitHub](./images/github-settings.png) -3. No painel **Configurar seu pipeline**, selecione **Pipeline inicial** e use a seguinte configuração YAML para o pipeline de CI: +7. Na barra lateral esquerda, selecione **Segredos e variáveis** e, em seguida, selecione **Ações**. -```yaml -trigger: -- main +8. Selecione **Novo segredo do repositório** e adicione cada uma destas variáveis: + - **Nome:** DATABRICKS_HOST **Segredo:** adicione a URL do Workspace do Databricks. + - **Nome:** DATABRICKS_TOKEN **Segredo:** Adicione o token de acesso gerado anteriormente. -pool: - vmImage: 'ubuntu-latest' +## Configurar os pipelines de CI/CD -steps: -- task: UsePythonVersion@0 - inputs: - versionSpec: '3.x' - addToPath: true +Agora que você armazenou as variáveis necessárias para acessar seu Workspace do Azure Databricks no GitHub, criará fluxos de trabalho para automatizar a ingestão e o processamento de dados, que serão disparados sempre que o repositório for atualizado. -- script: | - pip install databricks-cli - displayName: 'Install Databricks CLI' +1. Na página do repositório, selecione a guia **Ações** . -- script: | - databricks configure --token < - - EOF - displayName: 'Configure Databricks CLI' + ![Guia GitHub Actions](./images/github-actions.png) -- script: | - databricks fs cp dbfs:/FileStore/sample_sales.csv . --overwrite - displayName: 'Download Sample Data from DBFS' -``` +2. Selecione **configurar um fluxo de trabalho por conta própria** e insira o seguinte código: -4. Substitua `` e `` pelo URL e pelo token do host do Databricks. Isso configurará a CLI do Databricks antes de tentar usá-la. + ```yaml + name: CI Pipeline for Azure Databricks -5. Selecione **Salvar e executar**. + on: + push: + branches: + - main + pull_request: + branches: + - main -Esse arquivo YAML configurará um pipeline de CI que é acionado por alterações na ramificação `main` do repositório. O pipeline configura um ambiente do Python, instala a CLI do Databricks e baixa os dados de exemplo do seu workspace do Databricks. Essa é uma configuração comum para fluxos de trabalho de CI. + jobs: + deploy: + runs-on: ubuntu-latest -## Configurar um pipeline de CD + steps: + - name: Checkout code + uses: actions/checkout@v3 -1. Na barra do lado esquerdo, vá até **Pipelines > Lançamentos** e selecione **Criar lançamento**. + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' -2. Selecione o pipeline de build como a origem do artefato. + - name: Install Databricks CLI + run: | + pip install databricks-cli -3. Adicione um estágio e configure as tarefas que serão implantadas no Azure Databricks: + - name: Configure Databricks CLI + run: | + databricks configure --token < - - EOF - displayName: 'Configure Databricks CLI' +3. Nomeie o **pipeline de CI** do fluxo de trabalho e selecione **Confirmar alterações**. O pipeline será executado automaticamente e você poderá verificar seu status na guia **Ações** . - - script: | - databricks workspace import_dir /path/to/notebooks /Workspace/Notebooks - displayName: 'Deploy Notebooks to Databricks' -``` +Depois que o fluxo de trabalho for concluído, é hora de definir as configurações do pipeline de CD. -Antes de executar esse pipeline, substitua `/path/to/notebooks` pelo caminho para o diretório do notebook em seu repositório e `/Workspace/Notebooks` pelo caminho do arquivo em que você deseja que o notebook seja salvo no workspace do Databricks. +4. Vá para a página do espeço de trabalho, selecione **Computação** e, em seguida, selecione o cluster. -4. Selecione **Salvar e executar**. +5. Na página do cluster, selecione **Mais...** e, em seguida, selecione **Exibir JSON**. Copie o ID do cluster. -## Executar os pipelines +6. Abra o `job-config.json` no repositório e substitua `your_cluster_id` pelo ID do cluster que você acabou de copiar. Substitua também `/Workspace/Users/your_username/your_notebook` pelo caminho em seu workspace onde você deseja armazenar o notebook usado no pipeline. Confirme as alterações. -1. No repositório local, adicione a seguinte linha ao final do arquivo `sample_sales.csv`: +> **Observação:** se você for para a guia **Ações** , verá que o pipeline de CI começou a ser executado novamente. Como ele deve ser acionado sempre que uma confirmação é enviada, a alteração `job-config.json` implantará o pipeline conforme esperado. - ```sql - 2024-01-01,ProductG,1,500 - ``` +7. Na guia **Ações** crie um novo fluxo de trabalho chamado **Pipeline de CD** e insira o seguinte código: -2. Faça commit das alterações e efetue push delas para o repositório GitHub. + ```yaml + name: CD Pipeline for Azure Databricks -3. As alterações no repositório acionarão o pipeline de CI. Verifique se a execução do pipeline de CI foi concluída com êxito. + on: + push: + branches: + - main -4. Crie uma nova versão no pipeline de lançamento e implante os notebooks no Databricks. Verifique se os notebooks foram implantados e executados com êxito no workspace do Databricks. + jobs: + deploy: + runs-on: ubuntu-latest -## Limpar + steps: + - name: Checkout code + uses: actions/checkout@v3 -No portal do Azure Databricks, na página **Computação**, selecione seu cluster e selecione **■ Terminar** para encerrar o processo. + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' -Se você tiver terminado de explorar o Azure Databricks, poderá excluir os recursos que criou para evitar custos desnecessários do Azure e liberar capacidade em sua assinatura. + - name: Install Databricks CLI + run: pip install databricks-cli + - name: Configure Databricks CLI + run: | + databricks configure --token <não selecionado - - **Valores ausentes e NULL**: Não são exibidos no gráfico - -6. Salve a visualização e visualize-a no painel. -7. Selecione **Edição concluída** para exibir o painel como os usuários o verão. +7. Selecione **Publicar** para exibir o painel como os usuários o verão. Os painéis são uma ótima maneira de compartilhar tabelas de dados e visualizações com usuários corporativos. Você pode agendar os painéis para serem atualizados periodicamente e enviados por e-mail aos assinantes. diff --git a/Instructions/Exercises/images/github-actions.png b/Instructions/Exercises/images/github-actions.png new file mode 100644 index 0000000..90f3043 Binary files /dev/null and b/Instructions/Exercises/images/github-actions.png differ diff --git a/Instructions/Exercises/images/github-settings.png b/Instructions/Exercises/images/github-settings.png new file mode 100644 index 0000000..1a53c81 Binary files /dev/null and b/Instructions/Exercises/images/github-settings.png differ diff --git a/data/job-config.json b/data/job-config.json new file mode 100644 index 0000000..947b5de --- /dev/null +++ b/data/job-config.json @@ -0,0 +1,9 @@ +{ + "name": "CD pipeline", + "existing_cluster_id": "your_cluster_id", + "timeout_seconds": 1200, + "max_retries": 3, + "notebook_task": { + "notebook_path": "/Workspace/Users/your_username/your_notebook" + } +}