One place for hosting & domains

      Como usar o Git para Gerenciar seu Projeto de Redação


      Introdução

      O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o Git para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git.

      Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Pré-requisitos

      Passo 1 — Criando um Espaço de Trabalho para Seu Projeto de Redação

      Para gerenciar suas alterações, você criará um repositório Git local. Um repositório Git vive dentro de um diretório existente; portanto, comece criando um novo diretório para o seu artigo:

      Mude para o novo diretório artigo:

      O comando git init cria um novo repositório Git vazio no diretório atual. Execute esse comando agora:

      Você verá a seguinte saída que confirma que seu repositório foi criado:

      Output

      Initialized empty Git repository in /Users/sammy/artigo/.git/

      O arquivo .gitignore permite que você informe ao Git que alguns arquivos devem ser ignorados. Você pode usar isso para ignorar arquivos temporários que seu editor de texto possa criar ou arquivos de sistemas operacionais. No macOS, por exemplo, o aplicativo Finder cria arquivos .DS_Store em diretórios. Crie um arquivo .gitignore que os ignore:

      Adicione as seguintes linhas ao arquivo:

      .gitignore

      # Ignore Finder files
      .DS_store
      

      A primeira linha é um comentário, que o ajudará a identificar o que você está ignorando no futuro. A segunda linha especifica o arquivo a ser ignorado.

      Salve o arquivo e saia do editor.

      À medida que você descobrir mais arquivos que deseja ignorar, abra o arquivo .gitignore e adicione uma nova linha para cada arquivo ou diretório que deseja ignorar.

      Agora que seu repositório está configurado, você pode começar a trabalhar.

      Passo 2 — Salvando Seu Rascunho Inicial

      O Git só conhece os arquivos que você conta para ele. Só porque um arquivo existe no diretório que contém o repositório não significa que o Git irá rastrear suas alterações. Você precisa adicionar o arquivo ao repositório e confirmar as alterações.

      Crie um novo arquivo Markdown chamado artigo.md:

      Adicione algum texto ao arquivo:

      artigo.md

      # Como Usar o Git para Gerenciar seu Projeto de Redação
      
      ### Introdução
      
      O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. 
      
      Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.
      

      Salve as alterações e saia do editor.

      O comando git status mostrará o estado do seu repositório. Ele mostrará quais arquivos precisam ser adicionados para que o Git possa rastreá-los. Execute este comando:

      Você verá esta saída:

      Output

      On branch master No commits yet Untracked files: (use "git add <file>..." to include in what will be committed) .gitignore artigo.md nothing added to commit but untracked files present (use "git add" to track)

      Na saída, a seção Untracked files mostra os arquivos que o Git não está vendo. Esses arquivos precisam ser adicionados ao repositório para que o Git possa observá-los quanto a alterações. Use o comando git add para fazer isso:

      • git add .gitignore
      • git add artigo.md

      Agora execute o git status para verificar se esses arquivos foram adicionados:

      Output

      On branch master No commits yet Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: .gitignore new file: artigo.md

      Agora os dois arquivos estão listados na seção Changes to be committed, ou seja, alterações a serem confirmadas. O Git sabe sobre eles, mas ainda não criou um instantâneo do trabalho. Use o comando git commit para fazer isso.

      Quando você cria um novo commit, você precisa fornecer uma mensagem de commit. Uma boa mensagem de commit fala sobre quais são as suas alterações. Quando você está trabalhando com outras pessoas, quanto mais detalhadas forem suas mensagens de commit, melhor.

      Use o comando git commit para confirmar suas alterações:

      • git commit -m "Adicionar arquivo gitignore e versão inicial do artigo"

      A saída do comando mostra que os arquivos foram confirmados:

      Output

      [master (root-commit) 95fed84] Adicionar arquivo gitignore e versão inicial do artigo 2 files changed, 9 insertions(+) create mode 100644 .gitignore create mode 100644 artigo.md

      Use o comando git status para ver o estado do repositório:

      A saída mostra que não há alterações que precisam ser adicionadas ou confirmadas.

      Output

      On branch master nothing to commit, working tree clean

      Agora vamos ver como trabalhar com alterações.

      Passo 3 — Salvando Revisões

      Você adicionou sua versão inicial do artigo. Agora você adicionará mais texto para poder ver como gerenciar alterações com o Git.

      Abra o artigo no seu editor:

      Adicione um pouco mais de texto ao final do arquivo:

      ## Pré-requisitos
      
      * Git instalado em seu computador local. O tutorial [How to Contribute to Open Source: Getting Started with Git](https://www.digitalocean.com/community/tutorials/how-to-contribute-to-open-source-getting-started-with-git) orienta você na instalação do Git e cobre algumas informações básicas que você pode achar úteis. 
      

      Salve o artigo

      Use o comando git status para ver onde estão as coisas no seu repositório:

      A saída mostra que há alterações:

      Output

      On branch master Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git checkout -- <file>..." to discard changes in working directory) modified: artigo.md no changes added to commit (use "git add" and/or "git commit -a")

      Como esperado, o arquivo artigo.md sofreu alterações.

      Use git diff para ver o quais são elas:

      A saída mostra as linhas que você adicionou:

      diff --git a/artigo.md b/artigo.md
      index 77b081c..ef6c301 100644
      --- a/artigo.md
      +++ b/artigo.md
      @@ -5,3 +5,7 @@
       O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. 
      
       Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.
      +
      +## Pré-requisitos
      +
      +* Git instalado em seu computador local. O tutorial [How to Contribute to Open Source: Getting Started with Git](https://www.digitalocean.com/community/tutorials/how-to-contribute-to-open-source-getting-started-with-git) orienta você na instalação do Git e cobre algumas informações básicas que você pode achar úteis. 
      

      Na saída, linhas começando com um sinal de mais (+) são linhas que você adicionou. As linhas removidas apareceriam com um sinal de menos (-). As linhas inalteradas não teriam nenhum desses caracteres na frente.

      Usar git diff e git status é uma maneira útil de ver o que você mudou. Você também pode salvar o diff em um arquivo para visualizá-lo mais tarde com o seguinte comando:

      • git diff artigo.md > artigo_diff.diff

      O uso da extensão .diff ajudará seu editor de texto a aplicar o realce apropriado da sintaxe.

      Salvar as alterações no seu repositório é um processo de duas etapas. Primeiro, adicione o arquivo artigo.md novamente e depois faça o commit. O Git quer que você diga a ele explicitamente quais arquivos estão em cada commit, portanto, mesmo que você tenha adicionado o arquivo antes, você deve adicioná-lo novamente. Note que a saída do comando git status lembra você disso.

      Adicione o arquivo e faça o commit das alterações, fornecendo uma mensagem de commit:

      • git add artigo.md
      • git commit -m "adicionada seção de pré-requisitos"

      A saída verifica que o commit funcionou:

      Output

      [master 1fbfc21] adicionada seção de pré-requisitos 1 file changed, 4 insertions(+)

      Use git status para ver o status do seu repositório. Você verá que não há mais nada a fazer.

      Output

      On branch master nothing to commit, working tree clean

      Continue esse processo enquanto revisa seu artigo. Faça as alterações, verifique-as, adicione o arquivo e faça o commit das alterações com uma mensagem detalhada. Faça commit de suas alterações com a frequência que desejar. Você pode realizar um commit depois de concluir cada rascunho ou antes de fazer uma grande reformulação da estrutura do seu artigo.

      Se você enviar um rascunho de um documento para outra pessoa e ela fizer alterações, pegue a cópia e substitua o arquivo pelo dela. Em seguida, use git diff para ver rapidamente as alterações que ela fez. O Git verá as alterações, tenha você digitado diretamente ou substituido o arquivo por um que você baixou da web, e-mail ou outro local.

      Agora, vamos analisar o gerenciamento das versões do seu artigo.

      Passo 4 — Gerenciando Alterações

      Às vezes, é útil olhar para uma versão anterior de um documento. Sempre que você usou o git commit, você forneceu uma mensagem útil que resume o que você fez.

      O comando git log mostra o histórico de commit do seu repositório. Toda mudança que você fez commit tem uma entrada no log.

      Output

      commit 1fbfc2173f3cec0741e0a6b21803fbd0be511bc4 Author: Sammy Shark <sammy@digitalocean> Date: Thu Sep 19 16:35:41 2019 -0500 adicionada seção de pré-requisitos commit 95fed849b0205c49eda994fff91ec03642d59c79 Author: Sammy Shark <sammy@digitalocean> Date: Thu Sep 19 16:32:34 2019 -0500 Adicionar arquivo gitignore e versão inicial do artigo

      Cada commit possui um identificador específico. Você usa esse número para referenciar as alterações de um commit específico. Você só precisa dos primeiros caracteres do identificador. O comando git log --oneline fornece a você uma versão condensada do log com identificadores mais curtos:

      Output

      1fbfc21 adicionada seção de pré-requisitos 95fed84 Adicionar arquivo gitignore e versão inicial do artigo

      Para visualizar a versão inicial do seu arquivo, use git show e o identificador do commit. Os identificadores no seu repositório serão diferentes dos que estão nesses exemplos.

      • git show 95fed84 artigo.md

      A saída mostra os detalhes do commit, bem como as alterações que ocorreram durante esse commit:

      Output

      commit 95fed849b0205c49eda994fff91ec03642d59c79 Author: Sammy Shark <sammy@digitalocean> Date: Thu Sep 19 16:32:34 2019 -0500 Adicionar arquivo gitignore e versão inicial do artigo diff --git a/artigo.md b/artigo.md new file mode 100644 index 0000000..77b081c --- /dev/null +++ b/artigo.md @@ -0,0 +1,7 @@ +# Como Usar o Git para Gerenciar seu Projeto de Redação + +### Introdução + +O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. + +Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Para ver o próprio arquivo, modifique o comando levemente. Em vez de um espaço entre o identificador do commit e o arquivo, substitua por :./ assim:

      • git show 95fed84:./artigo.md

      Você verá o conteúdo desse arquivo, nessa revisão:

      Output

      ### Introdução O controle de versão não é apenas para código. É para qualquer coisa que você queira acompanhar, incluindo conteúdo. Usar o [Git](https://git-scm.com) para gerenciar o seu próximo projeto de redação permite a você exibir vários rascunhos ao mesmo tempo, ver diferenças entre esses rascunhos e até reverter para uma versão anterior. E se você estiver confortável com isso, poderá compartilhar seu trabalho com outras pessoas no GitHub ou em outros repositórios centrais do Git. Neste tutorial, você usará o Git para gerenciar um pequeno documento Markdown. Você armazenará uma versão inicial, fará o commit ou confirmação dela, fará alterações, visualizará a diferença entre essas alterações e revisará a versão anterior. Quando terminar, você terá um fluxo de trabalho que poderá aplicar aos seus próprios projetos de redação.

      Você pode salvar essa saída em um arquivo se precisar disso para outra coisa:

      • git show 95fed84:./artigo.md > old_artigo.md

      À medida que você fizer mais alterações, seu log aumentará e você poderá revisar todas as alterações feitas no seu artigo ao longo do tempo.

      Conclusão

      Neste tutorial, você usou um repositório Git local para rastrear as alterações no seu projeto de redação. Você pode usar essa abordagem para gerenciar artigos individuais, todas as postagens do seu blog ou até mesmo seu próximo romance. E se você enviar seu repositório para o GitHub, poderá convidar outras pessoas para ajudá-lo a editar seu trabalho.



      Source link

      Como Monitorar seu Banco de Dados PostgreSQL Gerenciado Usando o Nagios Core no Ubuntu 18.04


      O autor escolheu o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O monitoramento do banco de dados é essencial para entender como o banco de dados se comporta ao longo do tempo. Ele pode ajudá-lo a descobrir problemas de utilização ocultos e gargalos que ocorrem no seu banco de dados. A implementação de sistemas de monitoramento de banco de dados pode rapidamente se tornar uma vantagem a longo prazo, o que influenciará positivamente seu processo de gerenciamento de infraestrutura. Você poderá reagir rapidamente às alterações de status do seu banco de dados e será notificado rapidamente quando os serviços monitorados retornarem ao funcionamento normal.

      O Nagios Core é um sistema de monitoramento popular que você pode usar para monitorar seu banco de dados gerenciado. Os benefícios de usar o Nagios para esta tarefa são sua versatilidade — é fácil de configurar e utiliza um grande repositório de plugins disponíveis, e o mais importante, alerta integrado.

      Neste tutorial, você configurará o monitoramento do banco de dados PostgreSQL no Nagios Core utilizando o plugin check_postgres e configurar alertas baseados no Slack. No final, você terá um sistema de monitoramento funcionando em seu banco de dados PostgreSQL gerenciado e será notificado imediatamente sobre alterações de status de várias funcionalidades.

      Pré-requisitos

      Passo 1 — Instalando check_postgres

      Nesta seção, você fará o download da versão mais recente do plug-in check_postgres no Github e disponibilizará para o Nagios Core. Você também instalará o cliente PostgreSQL (psql), para que check_postgres consiga se conectar ao seu banco de dados gerenciado.

      Comece instalando o cliente PostgreSQL, executando o seguinte comando:

      • sudo apt install postgresql-client

      Em seguida, você baixará o check_postgres para o seu diretório home. Primeiro, navegue até ele:

      Vá para a página Github releases e copie o link da versão mais recente do plug-in. No momento da redação deste artigo, a versão mais recente do check_postgres era a 2.24.0; lembre-se de que isso será atualizado e, sempre que possível, a boa prática é usar a versão mais recente.

      Agora faça o download usando curl:

      • curl -LO https://github.com/bucardo/check_postgres/releases/download/2.24.0/check_postgres-2.24.0.tar.gz

      Extraia-o usando o seguinte comando:

      • tar xvf check_postgres-*.tar.gz

      Isso criará um diretório com o mesmo nome que o arquivo que você baixou. Essa pasta contém o executável check_postgres, que você precisará copiar para o diretório em que o Nagios armazena seus plugins (geralmente /usr/local/nagios/libexec/). Copie-o executando o seguinte comando:

      • sudo cp check_postgres-*/check_postgres.pl /usr/local/nagios/libexec/

      Em seguida, você precisará atribuir ao usuário nagios a propriedade sobre ele, para que ele possa ser executado a partir do Nagios:

      • sudo chown nagios:nagios /usr/local/nagios/libexec/check_postgres.pl

      O check_postgres está agora disponível para o Nagios e pode ser usado a partir dele. No entanto, ele fornece muitos comandos relativos a diferentes aspectos do PostgreSQL e, para uma melhor manutenção do serviço, é melhor dividi-los para que possam ser chamados separadamente. Você conseguirá isso criando um link simbólico para cada comando check_postgres no diretório do plugin.

      Navegue para o diretório onde o Nagios armazena plugins executando o seguinte comando:

      • cd /usr/local/nagios/libexec

      Em seguida, crie os links simbólicos com:

      • sudo perl check_postgres.pl --symlinks

      A saída será semelhante a esta:

      Output

      Created "check_postgres_archive_ready" Created "check_postgres_autovac_freeze" Created "check_postgres_backends" Created "check_postgres_bloat" Created "check_postgres_checkpoint" Created "check_postgres_cluster_id" Created "check_postgres_commitratio" Created "check_postgres_connection" Created "check_postgres_custom_query" Created "check_postgres_database_size" Created "check_postgres_dbstats" Created "check_postgres_disabled_triggers" Created "check_postgres_disk_space" Created "check_postgres_fsm_pages" Created "check_postgres_fsm_relations" Created "check_postgres_hitratio" Created "check_postgres_hot_standby_delay" Created "check_postgres_index_size" Created "check_postgres_indexes_size" Created "check_postgres_last_analyze" Created "check_postgres_last_autoanalyze" Created "check_postgres_last_autovacuum" Created "check_postgres_last_vacuum" Created "check_postgres_listener" Created "check_postgres_locks" Created "check_postgres_logfile" Created "check_postgres_new_version_bc" Created "check_postgres_new_version_box" Created "check_postgres_new_version_cp" Created "check_postgres_new_version_pg" Created "check_postgres_new_version_tnm" Created "check_postgres_pgagent_jobs" Created "check_postgres_pgb_pool_cl_active" Created "check_postgres_pgb_pool_cl_waiting" Created "check_postgres_pgb_pool_maxwait" Created "check_postgres_pgb_pool_sv_active" Created "check_postgres_pgb_pool_sv_idle" Created "check_postgres_pgb_pool_sv_login" Created "check_postgres_pgb_pool_sv_tested" Created "check_postgres_pgb_pool_sv_used" Created "check_postgres_pgbouncer_backends" Created "check_postgres_pgbouncer_checksum" Created "check_postgres_prepared_txns" Created "check_postgres_query_runtime" Created "check_postgres_query_time" Created "check_postgres_relation_size" Created "check_postgres_replicate_row" Created "check_postgres_replication_slots" Created "check_postgres_same_schema" Created "check_postgres_sequence" Created "check_postgres_settings_checksum" Created "check_postgres_slony_status" Created "check_postgres_table_size" Created "check_postgres_timesync" Created "check_postgres_total_relation_size" Created "check_postgres_txn_idle" Created "check_postgres_txn_time" Created "check_postgres_txn_wraparound" Created "check_postgres_version" Created "check_postgres_wal_files"

      O Perl listou todas as funções para as quais criou um link simbólico. Agora elas podem ser executadas na linha de comando, como de costume.

      Você baixou e instalou o plug-in check_postgres. Você também criou links simbólicos para todos os comandos do plug-in, para que possam ser usados individualmente no Nagios. No próximo passo, você criará um arquivo de serviço de conexão, que o check_postgres utilizará para se conectar ao seu banco de dados gerenciado.

      Passo 2 — Configurando Seu Banco de Dados

      Nesta seção, você criará um arquivo de serviço de conexão do PostgreSQL contendo as informações de conexão do seu banco de dados. A seguir, você testará os dados de conexão invocando o check_postgres nele.

      O arquivo do serviço de conexão é, por convenção, chamado pg_service.conf e deve estar localizado em /etc/postgresql-common/. Crie este arquivo usando seu editor de textos favorito (por exemplo, o nano):

      • sudo nano /etc/postgresql-common/pg_service.conf

      Adicione as seguintes linhas, substituindo os espaços reservados destacados pelos valores reais mostrados no Painel de Controle do Banco de Dados gerenciado na seção Connection Details:

      /etc/postgresql-common/pg_service.conf

      [managed-db]
      host=host
      port=porta
      user=nome_de_usuário
      password=senha
      dbname=defaultdb
      sslmode=require
      

      O arquivo do serviço de conexão pode abrigar vários grupos de informações de conexão com o banco de dados. O início de um grupo é sinalizado colocando seu nome entre colchetes. Depois disso vem os parâmetros de conexão (host, port, user, password e assim por diante), separados por novas linhas, que devem receber um valor.

      Salve e feche o arquivo quando terminar.

      Agora você testará a validade da configuração conectando-se ao banco de dados via check_postgres executando o seguinte comando:

      • ./check_postgres.pl --dbservice=managed-db --action=connection

      Aqui, você diz ao check_postgres qual grupo de informações de conexão com o banco de dados usar com o parâmetro --dbservice, e também especifica que ele deve apenas tentar se conectar a ele especificando connection como a ação.

      Sua saída será semelhante a esta:

      Output

      POSTGRES_CONNECTION OK: service=managed-db version 11.4 | time=0.10s

      Isto significa que o check_postgres conseguiu conectar-se ao banco de dados, de acordo com os parâmetros do pg_service.conf. Se você receber um erro, verifique novamente o que você acabou de inserir nesse arquivo de configuração.

      Você criou e preencheu um arquivo de serviço de conexão do PostgreSQL, que funciona como uma string de conexão. Você também testou os dados de conexão executando check_postgres e observando a saída. Na próxima etapa, você configurará o Nagios para monitorar várias partes do seu banco de dados.

      Passo 3 — Criando Serviços de Monitoramento no Nagios

      Agora você configurará o Nagios para monitorar várias métricas do seu banco de dados, definindo um host e vários serviços, que chamarão o plug-in check_postgres e seus links simbólicos.

      O Nagios armazena seus arquivos de configuração personalizados em /usr/local/nagios/etc/objects. Os novos arquivos adicionados lá devem ser ativados manualmente no arquivo de configuração central do Nagios, localizado em /usr/local/nagios/etc/nagios.cfg. Agora você deverá definir comandos, um host e vários serviços, que serão usados para monitorar seu banco de dados gerenciado no Nagios.

      Primeiro, crie uma pasta dentro de /usr/local/nagios/etc/objects para armazenar sua configuração relacionada ao PostgreSQL executando o seguinte comando:

      • sudo mkdir /usr/local/nagios/etc/objects/postgresql

      Você armazenará os comandos do Nagios para check_nagios em um arquivo chamado commands.cfg. Crie-o para edição:

      • sudo nano /usr/local/nagios/etc/objects/postgresql/commands.cfg

      Adicione as seguintes linhas:

      /usr/local/nagios/etc/objects/postgresql/commands.cfg

      define command {
          command_name           check_postgres_connection
          command_line           /usr/local/nagios/libexec/check_postgres_connection --dbservice=$ARG1$
      }
      
      define command {
          command_name           check_postgres_database_size
          command_line           /usr/local/nagios/libexec/check_postgres_database_size --dbservice=$ARG1$ --critical='$ARG2$'
      }
      
      define command {
          command_name           check_postgres_locks
          command_line           /usr/local/nagios/libexec/check_postgres_locks --dbservice=$ARG1$
      }
      
      define command {
          command_name           check_postgres_backends
          command_line           /usr/local/nagios/libexec/check_postgres_backends --dbservice=$ARG1$
      }
      

      Salve e feche o arquivo.

      Neste arquivo, você define quatro comandos do Nagios que chamam partes diferentes do plugin check_postgres (checando a conectividade, obtendo o número de locks e conexões e o tamanho de todo o banco de dados). Todos eles aceitam um argumento que é passado para o parâmetro --dbservice e especificam a qual dos bancos de dados definidos em pg_service.conf se conectar.

      O comando check_postgres_database_size aceita um segundo argumento que é passado para o parâmetro --critical, que especifica o ponto em que o armazenamento do banco de dados está ficando cheio. Os valores aceitos incluem 1 KB para um kilobyte, 1 MB para um megabyte e assim por diante, até exabytes (EB). Um número sem uma unidade de capacidade é tratado como sendo expresso em bytes.

      Agora que os comandos necessários estão definidos, você definirá o host (essencialmente o banco de dados) e seus serviços de monitoramento em um arquivo chamado services.cfg. Crie-o usando seu editor favorito:

      • sudo nano /usr/local/nagios/etc/objects/postgresql/services.cfg

      Inclua as seguintes linhas, substituindo db_max_storage_size por um valor referente ao armazenamento disponível do seu banco de dados. É recomendável configurá-lo para 90% do tamanho de armazenamento que você alocou para ele:

      /usr/local/nagios/etc/objects/postgresql/services.cfg

      define host {
            use                    linux-server
            host_name              postgres
            check_command          check_postgres_connection!managed-db
      }
      
      define service {
            use                    generic-service
            host_name              postgres
            service_description    PostgreSQL Connection
            check_command          check_postgres_connection!managed-db
            notification_options   w,u,c,r,f,s
      }
      
      define service {
            use                    generic-service
            host_name              postgres
            service_description    PostgreSQL Database Size
            check_command          check_postgres_database_size!managed-db!db_max_storage_size
            notification_options   w,u,c,r,f,s
      }
      
      define service {
            use                    generic-service
            host_name              postgres
            service_description    PostgreSQL Locks
            check_command          check_postgres_locks!managed-db
            notification_options   w,u,c,r,f,s
      }
      
      define service {
            use                    generic-service
            host_name              postgres
            service_description    PostgreSQL Backends
            check_command          check_postgres_backends!managed-db
            notification_options   w,u,c,r,f,s
      }
      

      Você primeiro define um host, para que o Nagios saiba a que entidade os serviços se relacionam. Em seguida, você cria quatro serviços, que chamam os comandos que você acabou de definir. Cada um deles passa managed-db como argumento, detalhando que o managed-db que você definiu no Passo 2 deve ser monitorado.

      Em relação às opções de notificação, cada serviço especifica que as notificações devem ser enviadas quando o estado do serviço se tornar WARNING,UNKNOWN, CRITICAL,OK (quando se recuperar de uma parada), quando o serviço iniciar oscilando, ou quando a parada programada iniciar ou terminar. Sem atribuir explicitamente um valor a essa opção, nenhuma notificação seria enviada (para os contatos disponíveis), exceto se acionada manualmente.

      Salve e feche o arquivo.

      Em seguida, você precisará dizer explicitamente ao Nagios para ler os arquivos de configuração deste novo diretório, editando o arquivo de configuração geral do Nagios. Abra-o para edição executando o seguinte comando:

      • sudo nano /usr/local/nagios/etc/nagios.cfg

      Encontre esta linha destacada no arquivo:

      /usr/local/nagios/etc/nagios.cfg

      ...
      # directive as shown below:
      
      cfg_dir=/usr/local/nagios/etc/servers
      #cfg_dir=/usr/local/nagios/etc/printers
      ...
      

      Acima dela, adicione a seguinte linha destacada:

      /usr/local/nagios/etc/nagios.cfg

      ...
      cfg_dir=/usr/local/nagios/etc/objects/postgresql
      cfg_dir=/usr/local/nagios/etc/servers
      ...
      

      Salve e feche o arquivo. Esta linha diz ao Nagios para carregar todos os arquivos de configuração a partir do diretório /usr/local/nagios/etc/objects/postgresql, onde seus arquivos de configuração estão localizados.

      Antes de reiniciar o Nagios, verifique a validade da configuração executando o seguinte comando:

      • sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg

      O final da saída será semelhante a este:

      Output

      Total Warnings: 0 Total Errors: 0 Things look okay - No serious problems were detected during the pre-flight check

      Isso significa que o Nagios não encontrou erros na configuração. Se ele lhe mostrar um erro, você também verá uma dica sobre o que deu errado, para poder corrigir o erro mais facilmente.

      Para fazer com que o Nagios recarregue sua configuração, reinicie seu serviço executando o seguinte comando:

      • sudo systemctl restart nagios

      Agora você pode navegar até o Nagios no seu navegador. Depois de carregado, clique na opção Services no menu à esquerda. Você verá o host do postgres e uma lista de serviços, junto com seus status atuais:

      PostgreSQL Monitoring Services - Pending

      Em breve, todos eles ficarão verdes e mostrarão o status OK. Você verá a saída do comando na coluna Status Information. Você pode clicar no nome do serviço e ver informações detalhadas sobre seu status e disponibilidade.

      Você adicionou comandos check_postgres, um host e vários serviços à sua instalação do Nagios para monitorar seu banco de dados. Você também verificou que os serviços estão funcionando corretamente, examinando-os por meio da interface web do Nagios. Na próxima etapa, você configurará os alertas baseados no Slack.

      Passo 4 — Configurando Alertas para o Slack

      Nesta seção, você configurará o Nagios para alertá-lo sobre eventos via Slack, publicando-os nos canais desejados em seu workspace.

      Antes de começar, efetue login no workspace desejado no Slack e crie dois canais nos quais você deseja receber mensagens de status do Nagios: um para host e outro para notificações de serviço. Se desejar, você pode criar apenas um canal em que receberá os dois tipos de alertas.

      Em seguida, vá para o app Nagios no Diretório de apps do Slack e click em Add Configuration. Você verá uma página para adicionar a Integração Nagios.

      Slack - Add Nagios Integration

      Click em Add Nagios Integration. Quando a página carregar, role para baixo e tome nota do token, porque você precisará dele mais adiante.

      Slack - Integration Token

      Agora você instalará e configurará o plugin Slack (escrito em Perl) para o Nagios no seu servidor. Primeiro, instale os pré-requisitos necessários do Perl executando o seguinte comando:

      • sudo apt install libwww-perl libcrypt-ssleay-perl -y

      Em seguida, faça o download do plug-in para o diretório de plugins do Nagios:

      • sudo curl https://raw.githubusercontent.com/tinyspeck/services-examples/master/nagios.pl -o slack.pl

      Torne-o executável executando o seguinte comando:

      Agora, você precisará editá-lo para conectar-se ao seu workspace usando o token que você obteve do Slack. Abra-o para edição:

      Localize as seguintes linhas no arquivo:

      /usr/local/nagios/libexec/slack.pl

      ...
      my $opt_domain = "foo.slack.com"; # Your team's domain
      my $opt_token = "your_token"; # The token from your Nagios services page
      ...
      

      Substitua foo.slack.com pelo domínio do seu workspace e your_token pelo seu token de integração do app Nagios, salve e feche o arquivo. O script agora poderá enviar solicitações apropriadas ao Slack, que você testará executando o seguinte comando:

      • ./slack.pl -field slack_channel=#nome_do_seu_canal -field HOSTALIAS="Test Host" -field HOSTSTATE="UP" -field HOSTOUTPUT="Host is UP" -field NOTIFICATIONTYPE="RECOVERY"

      Substitua nome_do_seu_canal pelo nome do canal em que você deseja receber alertas de status. O script exibirá informações sobre a solicitação HTTP feita ao Slack e, se tudo for executado corretamente, a última linha da saída será ok. Se você receber um erro, verifique novamente se o canal do Slack especificado existe no workspace.

      Agora você pode ir para o workspace do Slack e selecionar o canal que você especificou. Você verá uma mensagem de teste vinda do Nagios.

      Slack - Nagios Test Message

      Isso confirma que você configurou corretamente o script para o Slack. Agora você passará a configurar o Nagios para alertá-lo via Slack usando este script.

      Você precisará criar um contato para o Slack e dois comandos que enviarão mensagens para ele. Você armazenará essa configuração em um arquivo chamado slack.cfg, na mesma pasta que os arquivos de configuração anteriores. Crie-o para edição executando o seguinte comando:

      • sudo nano /usr/local/nagios/etc/objects/postgresql/slack.cfg

      Adicione as seguintes linhas:

      /usr/local/nagios/etc/objects/postgresql/slack.cfg

      define contact {
            contact_name                             slack
            alias                                    Slack
            service_notification_period              24x7
            host_notification_period                 24x7
            service_notification_options             w,u,c,f,s,r
            host_notification_options                d,u,r,f,s
            service_notification_commands            notify-service-by-slack
            host_notification_commands               notify-host-by-slack
      }
      
      define command {
            command_name     notify-service-by-slack
            command_line     /usr/local/nagios/libexec/slack.pl -field slack_channel=#service_alerts_channel
      }
      
      define command {
            command_name     notify-host-by-slack
            command_line     /usr/local/nagios/libexec/slack.pl -field slack_channel=#host_alerts_channel
      }
      

      Aqui você define um contato chamado slack, declara que ele pode ser contatado a qualquer momento e especifica quais comandos usar para notificar eventos relacionados ao serviço e ao host. Esses dois comandos são definidos depois e chamam o script que você acabou de configurar. Você precisará substituir service_alerts_channel e host_alerts_channel pelos nomes dos canais em que deseja receber mensagens de serviço e host, respectivamente. Se preferir, você pode usar os mesmos nomes de canais.

      De maneira semelhante à criação do serviço no último passo, é crucial definir as opções de notificação de serviço e host no contato, pois ele determina que tipo de alerta o contato receberá. A omissão dessas opções resultaria no envio de notificações somente quando acionadas manualmente a partir da interface web.

      Quando você terminar de editar, salve e feche o arquivo.

      Para habilitar o alerta através do contato slack que você acabou de definir, você precisará adicioná-lo ao grupo de contatos admin, definido no arquivo de configuração contacts.cfg, localizado em /usr/local/nagios/etc/objects/. Abra-o para edição executando o seguinte comando:

      • sudo nano /usr/local/nagios/etc/objects/contacts.cfg

      Localize o bloco de configuração parecido com este:

      /usr/local/nagios/etc/objects/contacts.cfg

      define contactgroup {
      
          contactgroup_name       admins
          alias                   Nagios Administrators
          members                 nagiosadmin
      }
      

      Adicione slack à lista de membros, assim:

      /usr/local/nagios/etc/objects/contacts.cfg

      define contactgroup {
      
          contactgroup_name       admins
          alias                   Nagios Administrators
          members                 nagiosadmin,slack
      }
      

      Salve e feche o arquivo.

      Por padrão, ao executar scripts, o Nagios não disponibiliza informações de host e serviço por meio de variáveis de ambiente, que é o que o script Slack requer para enviar mensagens significativas. Para remediar isso, você precisará definir a configuração enable_environment_macros em nagios.cfg como 1. Abra-o para edição executando o seguinte comando:

      • sudo nano /usr/local/nagios/etc/nagios.cfg

      Encontre a linha semelhante a essa:

      /usr/local/nagios/etc/nagios.cfg

      enable_environment_macros=0
      

      Altere o valor para 1, assim:

      /usr/local/nagios/etc/nagios.cfg

      enable_environment_macros=1
      

      Salve e feche o arquivo.

      Teste a validade da configuração do Nagios executando o seguinte comando:

      • sudo /usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg

      O final da saída será semelhante a:

      Output

      Total Warnings: 0 Total Errors: 0 Things look okay - No serious problems were detected during the pre-flight check

      Prossiga e reinicie o Nagios executando o seguinte comando:

      • sudo systemctl restart nagios

      Para testar a integração do Slack, você vai enviar uma notificação personalizada pela interface web. Recarregue a página de status Services do Nagios no seu navegador. Clique no serviço PostgreSQL Backends e clique em Send custom service notification à direita quando a página carregar.

      Nagios - Custom Service Notification

      Digite um comentário de sua escolha e clique em Commit e, em seguida, clique em Done. Você receberá imediatamente uma nova mensagem no Slack.

      Slack - Status Alert From Nagios

      Agora você integrou o Slack ao Nagios, para receber mensagens sobre eventos críticos e alterações de status imediatamente. Você também testou a integração acionando manualmente um evento no Nagios.

      Conclusão

      Agora você tem o Nagios Core configurado para monitorar seu banco de dados PostgreSQL gerenciado e relatar quaisquer mudanças de status e eventos para o Slack, para estar sempre de olho no que está acontecendo com seu banco de dados. Isso permitirá que você reaja rapidamente em caso de emergência, porque você receberá o feed de status em tempo real.

      Se você quiser saber mais sobre os recursos do check_postgres, consulte a documentação, onde você encontrará muito mais comandos que você pode eventualmente usar.

      Para obter mais informações sobre o que você pode fazer com seu banco de dados PostgreSQL gerenciado, visite a doumentação de produto.



      Source link

      Como Criar uma Imagem do Seu Ambiente Linux e Lançá-la na DigitalOcean


      Introdução

      O recurso Custom Images ou Imagens Personalizadas da DigitalOcean lhe permite trazer seu disco virtual personalizado de Linux e Unix-like de um ambiente local ou de outra plataforma de nuvem para a DigitalOcean e utilizá-lo para iniciar Droplets na DigitalOcean.

      Como descrito na documentação do Custom Images, os seguintes tipos de imagens são suportados nativamente pela ferramenta de upload do Custom Images:

      Embora imagens com formato ISO não sejam oficialmente suportadas, você pode aprender como criar e carregar uma imagem compatível usando o VirtualBox seguindo o tutorial How to Create a DigitalOcean Droplet from an Ubuntu ISO Format Image.

      Se você ainda não tem uma imagem compatível para carregar na DigitalOcean, você pode criar e comprimir uma imagem de disco do seu sistema Unix-like ou Linux, desde que ela tenha o software e os drivers de pré-requisitos instalados.

      Vamos começar assegurando que sua imagem atende ao requisitos do Custom Images. Para fazer isso, vamos configurar o sistema e instalar alguns pré-requisitos de software. Depois, vamos criar a imagem utilizando o utilitário de linha de comando dd e comprimí-la usando o gzip. Na sequência, vamos fazer o upload desse arquivo de imagem compactado para o DigitalOcean Spaces, de onde podemos importá-lo como uma Imagem Personalizada. Finalmente, vamos inicializar um droplet usando a imagem enviada

      Pré-requisitos

      Se possível, você deve usar uma das imagens fornecidas pela DigitalOcean como base, ou uma imagem de nuvem oficial fornecida pela distribuição como o Ubuntu Cloud. Então você pode instalar softwares e aplicaçoes em cima dessa imagem de base para fazer uma nova imagem usando ferramentas como o Packer e o VirtualBox. Muitos provedores de nuvem e ambientes de virtualização também fornecem ferramentas para exportar discos virtuais para um dos formatos compatíveis listados acima, assim, se possível, você deve usá-las para simplificar o processo de importação. Nos casos em que você precisa criar manualmente uma imagem de disco do seu sistema você pode seguir as instruções nesse guia. Observe que essas instruções só foram testadas com um sistema Ubuntu 18.04 e as etapas podem variar dependendo do sistema operacional e da configuração do seu servidor.

      Antes de começar com este tutorial, você deve ter o seguinte disponível para você:

      • Um sistema Linux ou Unix-like que atenda a todos os requisitos listados na documentação de produto do Custom Images. Por exemplo, seu disco de boot deve ter:

        • Um tamanho máximo de 100GB
        • Um tabela de partição MBR ou GPT com um gerenciador de boot grub
        • Drivers do VirtIO instalados
      • Um usuário não-root com privilégios administrativos disponível para você no sistema que você está fazendo imagem. Para criar um novo usuário e conceder a ele privilégios administrativos no Ubuntu 18.04, siga nosso tutorial de Configuração Inicial de Servidor com Ubuntu 18.04. Para aprender como fazer isto no Debian 9, consulte Configuração Inicial de Servidor com Debian 9.

      • Um dispositivo de armazenamento adicional usado para armazenar a imagem de disco criada neste guia, preferivelmente tão grande quanto o disco que está sendo copiado. Isso pode ser um volume de armazenamento em blocos anexado, um drive externo USB, um espaço em disco adicional, etc.

      • Um Space na DigitalOcean e o utilitário de transferência de arquivos s3cmd configurado para uso com o seu Space. Para aprender como criar um Space, consulte o Guia Rápido do Spaces. Para aprender como configurar o s3cmd para uso com o seu Space, consulte o Guia de Configuração do s3cmd 2.x.

      Passo 1 — Instalando o Cloud-Init e ativando o SSH

      Para começar, vamos instalar o pacote de inicialização do cloud-Init. O cloud-init é um conjunto de scripts que executam no boot para configurar certas propriedades da instância de nuvem como a localidade padrão, hostname, chaves SSH e dispositivos de rede.

      Os passos para a instalação do cloud-init vão variar dependendo do sistema operacional que você instalou. Em geral, o pacote cloud-init deve estar disponível no gerenciador de pacotes do seu SO, assim se você não estiver utilizando uma distribuição baseada no Debian, você deve substituir o apt nos seguintes passos pelo seu comando do gerenciador de pacotes específico da distribuição.

      Instalando o cloud-init

      Neste guia, vamos utilizar um servidor Ubuntu 18.04 e então usaremos o apt para baixar e instalar o pacote cloud-init. Observe que o cloud-init pode já estar instalado em seu sistema (algumas distribuições Linux instalam o cloud-initpor padrão). Para verificar, efetue o login em seu servidor e execute o seguinte comando:

      Se você vir a seguinte saída, o cloud-init já foi instalado no seu servidor e você pode continuar configurando-o para uso com a DigitalOcean:

      Output

      usage: /usr/bin/cloud-init [-h] [--version] [--file FILES] [--debug] [--force] {init,modules,single,query,dhclient-hook,features,analyze,devel,collect-logs,clean,status} ... /usr/bin/cloud-init: error: the following arguments are required: subcommand

      Se, em vez disso, você vir o seguinte, você precisa instalar o cloud-init:

      Output

      cloud-init: command not found

      Para instalar o cloud-init, atualize o índice de pacotes e em seguida instale o pacote usando o apt:

      • sudo apt update
      • sudo apt install cloud-init

      Agora que instalamos o cloud-init, vamos configurá-lo para uso com a DigitalOcean, assegurando que ele utilize o datasource ConfigDrive. O datasource do cloud-init determina como o cloud-init procurará e atualizará a configuração e os metadados da instância. Os Droplets da DigitalOcean usam o datasource ConfigDrive, por isso, vamos verificar se ele vem em primeiro lugar na lista de datasources que o cloud-init pesquisa sempre que o Droplet inicializa.

      Reconfigurando o cloud-init

      Por padrão, no Ubuntu 18.04, o cloud-init configura a si mesmo para utilizar o datasource NoCloud primeiro. Isso irá causar problemas ao executar a imagem na DigitalOcean, por isso precisamos reconfigurar o cloud-init para utilizar o datasource ConfigDdrive e garantir que o cloud-init execute novamente quando a imagem é lançada na DigitalOcean.

      A partir da linha de comando, navegue até o diretório /etc/cloud/cloud.cfg.d:

      • cd /etc/cloud/cloud.cfg.d

      Use o comando ls para listar os arquivos de configuração do cloud-init presentes dentro do diretório:

      Output

      05_logging.cfg 50-curtin-networking.cfg 90_dpkg.cfg curtin-preserve-sources.cfg README

      Dependendo da sua instalação, alguns desses arquivos podem não estar presentes. Se presente, exclua o arquivo 50-curtin-networking.cfg, que configura as interfaces de rede para seu servidor Ubuntu. Quando a imagem é lançada na DigitalOcean, o cloud-init irá executar e reconfigurar estas interfaces automaticamente, portanto esse arquivo não é necessário. Se esse arquivo não for excluído, o Droplet da DigitalOcean criado a partir dessa imagem Ubuntu terá suas interfaces configuradas incorretamente e não serão acessíveis pela internet:

      • sudo rm 50-curtin-networking.cfg

      Em seguida, vamos executar dpkg-reconfigure cloud-init para remover o datasource NoCloud, garantindo que o cloud-init procure e localize o datasource ConfigDrive usado na DigitalOcean:

      • sudo dpkg-reconfigure cloud-init

      Você deve ver o seguinte menu gráfico:

      O datasource NoCloud está inicialmente destacado. Pressione ESPAÇO para desmarcá-lo e, em seguida, pressione ENTER.

      Finalmente, navegue até /etc/netplan:

      Remova o arquivo 50-cloud-init.yaml, que foi gerado a partir do arquivo de rede cloud-init que removemos anteriormente:

      • sudo rm 50-cloud-init.yaml

      A etapa final é garantir que limpemos a configuração da execução inicial do cloud-init para que ela seja executada novamente quando a imagem for lançada na DigitalOcean.

      Para fazer isso, execute cloud-init clean:

      Neste ponto você instalou e configurou o cloud-init para uso com a DigitalOcean. Agora você pode seguir para ativar o acesso SSH ao seu droplet.

      Ativar o Acesso SSH

      Depois que você instalou e configurou o cloud-init, o próximo passo é assegurar que você tenha um usuário e senha de administrador não-root disponível para você em sua máquina, conforme descrito nos pré-requisitos. Este passo é essencial para diagnosticar quaisquer erros que possam surgir após o upload da sua imagem e o lançamento do seu droplet. Se uma configuração de rede preexistente ou uma configuração incorreta do cloud-init tornar o seu Droplet inacessível na rede, você pode utilizar esse usuário em combinação ao Console do Droplet da DigitalOcean para acessar seu sistema e diagnosticar quaisquer problemas que possam ter surgido.

      Depois que você tiver configurado seu usuário administrativo não-root, a etapa final é garantir que você tenha um servidor SSH instalado e executando. O SSH geralmente vem pré-instalado em muitas distribuições populares do Linux. O procedimento para verificar se um processo está executando irá variar dependendo do sistema operacional do seu servidor. Se você não tiver certeza de como fazer isso, consulte a documentação do seu sistema operacional sobre o gerenciamento de serviços. No Ubuntu, você pode verificar que o SSH está funcionando utilizando este comando:

      Você deve ver a seguinte saída:

      Output

      ● ssh.service - OpenBSD Secure Shell server Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enabled) Active: active (running) since Mon 2018-10-22 19:59:38 UTC; 8 days 1h ago Docs: man:sshd(8) man:sshd_config(5) Process: 1092 ExecStartPre=/usr/sbin/sshd -t (code=exited, status=0/SUCCESS) Main PID: 1115 (sshd) Tasks: 1 (limit: 4915) Memory: 9.7M CGroup: /system.slice/ssh.service └─1115 /usr/sbin/sshd -D

      Se o SSH não estiver em execução, você pode instalá-lo usando o apt (nas distribuições baseadas em Debian):

      • sudo apt install openssh-server

      Por padrão, o servidor SSH vai iniciar no boot a menos que esteja configurado de outra forma. Isso é desejável ao executar o sistema na nuvem, já que a DigitalOcean pode copiar automaticamente sua chave pública e conceder acesso SSH imediato ao seu Droplet após a criação.

      Depois que você criou um usuário administrativo não-root, ativou o SSH, e instalou o cloud-init, você está pronto para continuar criando uma imagem do seu disco de boot.

      Passo 2 — Criando uma Imagem de Disco

      Neste passo, vamos criar uma imagem de disco de formato RAW usando o utilitário de linha de comando dd, e compactá-lo usando o gzip. Vamos então carregar a imagem para o Spaces da DigitalOcean usando o s3cmd.

      Para começar, efetue login em seu servidor, e inspecione o arranjo de dispositivos de bloco para o seu sistema usando lsblk:

      Você deverá ver algo como o seguinte:

      Output

      NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT loop0 7:0 0 12.7M 1 loop /snap/amazon-ssm-agent/495 loop1 7:1 0 87.9M 1 loop /snap/core/5328 vda 252:0 0 25G 0 disk └─vda1 252:1 0 25G 0 part / vdb 252:16 0 420K 1 disk

      Nesse caso, observamos que nosso disco principal de boot é o /dev/vda, um disco de 25GB, e a partição primária, montada no /, é a /dev/vda1. Na maioria dos casos o disco contendo a partição montada no / será o disco de origem para a imagem. Vamos usar o dd para criar uma imagem do /dev/vda.

      Neste ponto, você deve decidir onde você quer armazenar a imagem de disco. Uma opção é anexar outro dispositivo de armazenamento em bloco, de preferência tão grande quanto o disco que você está fazendo a imagem. Em seguida, você pode salvar a imagem neste disco temporário anexado e enviá-la para o Spaces da DigitalOcean.

      Se você tem acesso físico ao servidor, você pode adicionar um drive adicional à máquina ou anexar outro dispositivo de armazenamento, como um disco USB externo.

      Outra opção, que iremos demonstrar nesse guia, é copiar a imagem por SSH para uma máquina local, a partir da qual você pode enviá-la para o Spaces.

      Independentemente do método escolhido, verifique se o dispositivo de armazenamento no qual você salvou a imagem compactada tem espaço livre suficiente. Se o disco que você está fazendo imagem está quase vazio, você pode esperar que o arquivo de imagem compactado seja significativamente menor que o disco original.

      Atenção: Antes de rodar o seguinte comando dd, certifique-se de que todos os aplicativos críticos tenham sido parados e seu sistema esteja o mais folgado possível. Copiar um disco sendo usado ativamente pode resultar em alguns arquivos corrompidos, portanto, certifique-se de interromper qualquer operação que use muitos dados e encerre o máximo possível de aplicativos em execução.

      Opção 1: Criando a Imagem Localmente

      A sintaxe para o comando dd que vamos executar é a seguinte:

      • dd if=/dev/vda bs=4M conv=sparse | pv -s 25G | gzip > /mnt/tmp_disk/ubuntu.gz

      Neste caso, estamos selecionando /dev/vda como o disco de entrada para se fazer imagem, e definindo o tamanho dos blocos de entrada/saída para 4MB (sendo que o padrão é 512 bytes). Isso geralmente acelera um pouco as coisas. Além disso, estamos usando a flag conv=sparse para minimizar o tamanho do arquivo de saída pulando o espaço vazio. Para aprender mais sobre parâmetros do dd, consulte a sua manpage.

      Em seguida, fazemos um pipe da saída para o utilitário de visualização de pipe pv para que possamos acompanhar o progresso da transferência visualmente (esse pipe é opcional e requer a instalação do pv usando o gerenciador de pacotes). Se você sabe o tamanho do disco inicial (nesse caso é 25GB), você pode adicionar -s 25G ao pipe do pv para ter uma estimativa de quando a transferência será concluída.

      Fazemos então um pipe de tudo isso para o gzip e salvamos em um arquivo chamado ubuntu.gz no volume de armazenamento de bloco temporário que anexamos ao servidor. Substitua /mnt/tmp_disk com o caminho para o dispositivo de armazenamento externo que você anexou ao seu servidor.

      Opção 2: Criando a Imagem via SSH

      Em vez de provisionar armazenamento adicional para sua máquina remota, você também pode executar a cópia via SSH se tiver espaço em disco suficiente disponível na sua máquina local. Observe que, dependendo da largura de banda disponível para você, isso pode ser lento e você pode incorrer em custos adicionais para a transferência de dados pela rede.

      Para copiar e compactar o disco via SSH, execute o seguinte comando em sua máquina local:

      • ssh usuário_remoto@ip_do_seu_servidor "sudo dd if=/dev/vda bs=4M conv=sparse | gzip -1 -" | dd of=ubuntu.gz

      Neste caso, estamos fazendo SSH para o nosso servidor remoto executando o comando dd lá, e fazendo um pipe da saída para o gzip. Em seguida, transferimos a saída do gzip pela rede e a salvamos localmente como ubuntu.gz. Certifique-se de que você tenha o utilitário dd disponível em sua máquina local antes de executar esse comando:

      Output

      /bin/dd

      Crie o arquivo de imagem compactado usando qualquer um dos métodos acima. Isso pode levar várias horas, dependendo do tamanho do disco que você está criando e do método que você está usando para criar a imagem.

      Depois de criar o arquivo de imagem compactado, você pode passar a enviá-lo para seus Spaces da DigitalOcean usando o s3cmd.

      Passo 3 — Fazendo Upload da Imagem para Spaces e Custom Images

      Conforme descrito nos pré-requisitos, você deve ter o s3cmd instalado e configurado para uso com seu Space da DigitalOcean na máquina que contém sua imagem compactada.

      Localize o arquivo de imagem compactado e faça o upload dele para seu Space usando o s3cmd:

      Nota: Você deve substituir your_space_name pelo nome do seu Space e não a sua URL. Por exemplo, se a URL do seu Space é https://example-space-name.nyc3.digitaloceanspaces.com, então o nome do seu Space é example-space-name.

      • s3cmd put /caminho_da_imagem/ubuntu.gz s3://your_space_name

      Quando o upload estiver concluído, navegue até seu Space usando o Painel de Controle da DigitalOcean, e localize a imagem na lista de arquivos. Tornaremos a imagem publicamente acessível temporariamente para que o Custom Images possa acessá-la e salvar uma cópia.

      À direita da lista de imagens, clique no menu suspenso More e, em seguida, clique em Manage Permissions:

      Em seguida, clique no botão de opção ao lado de Public e clique em Update para tornar a imagem publicamente acessível.

      Atenção: Sua imagem estará temporariamente acessível publicamente para qualquer pessoa com o caminho do seu Space durante este processo. Se você gostaria de evitar tornar sua imagem temporariamente pública, você pode criar sua Imagem Personalizada usando a API da DigitalOcean. Certifique-se de definir sua imagem como Private usando o procedimento acima depois que sua imagem for transferida com sucesso para o Custom Images.

      Busque a URL do Spaces para sua imagem passando o mouse sobre o nome da imagem no Painel de controle, e clique em Copy URL na janela que aparece.

      Agora, navegue para Images na barra de navegação à esquerda, e depois para Custom Images.

      A partir daqui, envie sua imagem usando esta URL, conforme detalhado na Documentação de Produto do Custom Images.

      Você pode então criar um Droplet a partir desta imagem. Observe que você precisa adicionar uma chave SSH ao Droplet na criação. Para aprender como fazer isso, consulte How to Add SSH Keys to Droplets.

      Uma vez que o seu Droplet inicializa, se você puder fazer SSH nele, você lançou com sucesso a sua Imagem Personalizada como um Droplet da DigitalOcean.

      Fazendo Debug

      Se você tentar fazer SSH no seu Droplet e não conseguir conectar, certifique-se de que sua imagem atenda aos requisitos listados e tenha o cloud-init e o SSH instalados e configurados corretamente. Se você ainda não conseguir acessar o Droplet, você pode tentar utilizar o Console do Droplet da DigitalOcean e o usuário não-root que você criou anteriormente para explorar o sistema e fazer o debug das configurações de sua rede, do cloud-init e do SSH. Outra maneira de fazer o debug de sua imagem é usar uma ferramenta de virtualização como o Virtualbox para inicializar sua imagem de disco dentro de uma máquina virtual, e fazer o debug da configuração do seu sistema a partir da VM.

      Conclusão

      Neste guia, você aprendeu como criar uma imagem de disco de um sistema Ubuntu 18.04 usando o utilitário de linha de comando dd e fazer o upload dela para a DigitalOcean como uma Custom Image ou Imagem Personalizada a partir da qual você pode lançar Droplets.

      As etapas neste guia podem variar dependendo do seu sistema operacional, do hardware existente e da configuração do kernel, mas, em geral, as imagens criadas a partir de distribuições populares do Linux devem funcionar usando esse método. Certifique-se de seguir cuidadosamente as etapas de instalação e configuração do cloud-init e de garantir que o sistema atenda a todos os requisitos listados na seção pré-requisitos acima.

      Para aprender mais sobre Custom Images, consulte a documentação de produto do Custom Images.

      Por Hanif Jetha



      Source link