├── .gitignore ├── README.md ├── aws-terraform ├── README.md └── main.tf ├── doctos ├── aws.md └── terraform.md └── local-vagrant ├── README.md ├── Vagrantfile ├── bashrc └── bootstrap.sh /.gitignore: -------------------------------------------------------------------------------- 1 | # Created by https://www.gitignore.io 2 | 3 | #vagrant 4 | .vagrant 5 | *.log 6 | 7 | ### Java ### 8 | *.class 9 | /classes 10 | 11 | # Mobile Tools for Java (J2ME) 12 | .mtj.tmp/ 13 | 14 | # Package Files # 15 | *.jar 16 | *.war 17 | *.ear 18 | 19 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 20 | hs_err_pid* 21 | 22 | 23 | ### Intellij ### 24 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm 25 | 26 | *.iml 27 | 28 | ## Directory-based project format: 29 | .idea/ 30 | # if you remove the above rule, at least ignore the following: 31 | 32 | # User-specific stuff: 33 | # .idea/workspace.xml 34 | # .idea/tasks.xml 35 | # .idea/dictionaries 36 | 37 | # Sensitive or high-churn files: 38 | # .idea/dataSources.ids 39 | # .idea/dataSources.xml 40 | # .idea/sqlDataSources.xml 41 | # .idea/dynamic.xml 42 | # .idea/uiDesigner.xml 43 | 44 | # Gradle: 45 | #.idea/gradle.xml 46 | #.idea/libraries 47 | build/ 48 | gradle-app.setting 49 | !gradle-wrapper.jar 50 | 51 | # Mongo Explorer plugin: 52 | # .idea/mongoSettings.xml 53 | 54 | ## File-based project format: 55 | *.ipr 56 | *.iws 57 | 58 | ## Plugin-specific files: 59 | 60 | # IntelliJ 61 | out/ 62 | 63 | # mpeltonen/sbt-idea plugin 64 | .idea_modules/ 65 | 66 | # JIRA plugin 67 | atlassian-ide-plugin.xml 68 | 69 | # Crashlytics plugin (for Android Studio and IntelliJ) 70 | com_crashlytics_export_strings.xml 71 | crashlytics.properties 72 | crashlytics-build.properties 73 | 74 | 75 | ### Eclipse ### 76 | *.pydevproject 77 | .metadata 78 | .gradle 79 | bin/ 80 | tmp/ 81 | *.tmp 82 | *.bak 83 | *.swp 84 | *~.nib 85 | local.properties 86 | .settings/ 87 | .loadpath 88 | 89 | # Eclipse Core 90 | .project 91 | 92 | # External tool builders 93 | .externalToolBuilders/ 94 | 95 | # Locally stored "Eclipse launch configurations" 96 | *.launch 97 | 98 | # CDT-specific 99 | .cproject 100 | 101 | # JDT-specific (Eclipse Java Development Tools) 102 | .classpath 103 | 104 | # PDT-specific 105 | .buildpath 106 | 107 | # sbteclipse plugin 108 | .target 109 | 110 | # TeXlipse plugin 111 | .texlipse 112 | 113 | 114 | ### Maven ### 115 | target/ 116 | pom.xml.tag 117 | pom.xml.releaseBackup 118 | pom.xml.versionsBackup 119 | pom.xml.next 120 | release.properties 121 | dependency-reduced-pom.xml 122 | buildNumber.properties 123 | 124 | ### local util classes 125 | /**/__util/* 126 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # hands-on-microservices 2 | 3 | Os exercícios estão cada um em um branch separado e que devem ser feitos na **ordem**, o ideal é fazer em aula, junto com a explicação: 4 | 5 | [exercício 1](https://github.com/luizroos/hands-on-microservices/tree/e1) 6 | 7 | [exercício 2](https://github.com/luizroos/hands-on-microservices/tree/e2) 8 | 9 | [exercício 3](https://github.com/luizroos/hands-on-microservices/tree/e3) 10 | 11 | [exercício 4](https://github.com/luizroos/hands-on-microservices/tree/e4) 12 | 13 | [exercício 5](https://github.com/luizroos/hands-on-microservices/tree/e5) 14 | 15 | [exercício 6](https://github.com/luizroos/hands-on-microservices/tree/e6) 16 | 17 | [exercício 7](https://github.com/luizroos/hands-on-microservices/tree/e7) 18 | 19 | [exercício 8](https://github.com/luizroos/hands-on-microservices/tree/e8) 20 | 21 | [exercício 9](https://github.com/luizroos/hands-on-microservices/tree/e9) 22 | 23 | [exercício 10](https://github.com/luizroos/hands-on-microservices/tree/e10) 24 | 25 | [exercício 11](https://github.com/luizroos/hands-on-microservices/tree/e11) 26 | 27 | [exercício 12](https://github.com/luizroos/hands-on-microservices/tree/e12) 28 | 29 | [exercício 13](https://github.com/luizroos/hands-on-microservices/tree/e13) 30 | 31 | [exercício 14](https://github.com/luizroos/hands-on-microservices/tree/e14) 32 | 33 | [exercício 15](https://github.com/luizroos/hands-on-microservices/tree/e15) 34 | 35 | [exercício 16](https://github.com/luizroos/hands-on-microservices/tree/e16) 36 | 37 | ## Instalando o ambiente 38 | 39 | Nos exercícios, vamos usar [java](https://www.java.com/pt-BR/), [docker](https://www.docker.com/), [git](https://git-scm.com/), [apache bench](https://httpd.apache.org/docs/2.4/programs/ab.html), [ccm](https://www.datastax.com/blog/ccm-development-tool-creating-local-cassandra-clusters), [kubernetes](https://kubernetes.io/pt/), etc. Para isso vamos subir um [ubuntu](https://ubuntu.com) e realizar nossos testes nele. 40 | 41 | ### Local com vagrant e virtual box 42 | 43 | Esse é o jeito mais barato e que eu sugiro para desenvolvedores. Vamos subir uma máquina virtual no seu computador usando uma ferramenta chamada vagrant. Verique os passos em [local-vagrant](local-vagrant/README.md) para mais detalhes. 44 | 45 | ### Local importando a imagem direto na máquina virtual 46 | 47 | Essa opção não precisa instalar o vagrant, já vai importar para virtual box a imagem pronta para uso. 48 | 49 | Instale a [virtualbox](https://www.virtualbox.org/), acesse o diretório https://drive.google.com/drive/u/0/folders/1DCq3_ufUVXUHXYSd3MZhCqnZi2NmTCYT e siga as instruções de https://docs.google.com/document/d/1gVOlSwZKuPcMl5v2zVbvsRZ5dfyi4sv0C970EfW6VKQ/edit?usp=sharing 50 | 51 | ### Usando terraform, criando uma instância EC2 na AWS 52 | 53 | O jeito mais fácil de criar uma instância EC2 na AWS é usando alguma ferramenta para automatizar esse processo. Verique os passos em [aws-terraform](aws-terraform/README.md) para mais detalhes. 54 | 55 | ## Rodando o primeiro container 56 | 57 | Dentro da vm, execute: 58 | 59 | ``` 60 | docker pull alpine 61 | ``` 62 | 63 | Isso vai baixar uma imagem chamada [alpine](https://hub.docker.com/_/alpine) do Docker Registry e salva-la no nosso sistema. Você pode ver as imagens salvas com o comando: 64 | 65 | ``` 66 | docker images 67 | ``` 68 | 69 | Agora vamos executar um container baseado nessa imagem: 70 | 71 | ``` 72 | docker run alpine ls -l 73 | ``` 74 | 75 | Esse comando criou um container a partir da imagem alpine, e executou o comando 'ls -l' dentro do container, mostrando o output do comando para o client docker. Agora tente: 76 | 77 | ``` 78 | docker run -it alpine /bin/sh 79 | ``` 80 | 81 | ## Clonando o repositório da aplicação 82 | 83 | Dentro da máquina virtual, faça clone do repositório e checkout desse branch: 84 | 85 | ``` 86 | git clone https://github.com/luizroos/hands-on-microservices.git 87 | ``` -------------------------------------------------------------------------------- /aws-terraform/README.md: -------------------------------------------------------------------------------- 1 | # hands-on-microservices 2 | 3 | Podemos criar o ambiente na AWS usando uma ferramenta chamada terraform 4 | 5 | O Terraform é uma ferramenta de código aberto para provisionamento de infraestrutura como código. Com o Terraform, é possível definir e gerenciar a infraestrutura de nuvem de maneira declarativa, o que significa que é possível descrever a infraestrutura que se deseja e o Terraform irá criar e gerenciar essa infraestrutura automaticamente. Com o Terraform, é possível gerenciar recursos em diversas nuvens e provedores de serviços, como AWS, Azure, Google Cloud, entre outros. 6 | 7 | Primeiro passo é, se você não tiver, [criar uma conta](/doctos/aws.md) na AWS 8 | 9 | O segundo passo é você [instalar o Terraform](/doctos/terraform.md) no seu computador 10 | 11 | ## Criando o ambiente de testes 12 | 13 | Após criada a conta AWS, de posse das chaves de acesso e com o Terraform instalado, faça o clone desse repositório 14 | 15 | ``` 16 | git clone https://github.com/luizroos/hands-on-microservices 17 | ``` 18 | 19 | Acesse o diretório aws-terraform e execute: 20 | 21 | ``` 22 | terraform init 23 | ``` 24 | 25 | Logo após 26 | 27 | ``` 28 | terraform apply -var 'aws_access_key=' -var 'aws_secret_key=' -var 'aws_keypair=' 29 | ``` 30 | 31 | Aguarde até que a máquina tenha sido gerada e depois conecte via ssh (costuma levar uns 3 ~ 4 minutos). A chave de acesso para conectar via ssh está no arquivo aws_aulas.pem, você deve conseguir conectar executando algo como: 32 | 33 | ``` 34 | ssh -i ubuntu@ec2-44-201-202-137.compute-1.amazonaws.com 35 | ``` 36 | 37 | **Lembre** depois da aula de destruir o ambiente, senão a AWS vai te cobrar pelos recursos. Basta executar: 38 | 39 | ``` 40 | terraform destroy -var 'aws_access_key=' -var 'aws_secret_key=' -var 'aws_keypair=' 41 | ``` 42 | -------------------------------------------------------------------------------- /aws-terraform/main.tf: -------------------------------------------------------------------------------- 1 | variable "aws_keypair" { 2 | description = "Informe o nome da sua chave key-pair que você deseja usar para conectar nessa instância" 3 | } 4 | 5 | variable "aws_access_key" { 6 | description = "aws access key" 7 | } 8 | 9 | variable "aws_secret_key" { 10 | description = "aws secret key" 11 | } 12 | 13 | # Configura as credenciais do AWS 14 | provider "aws" { 15 | region = "us-east-1" 16 | access_key = var.aws_access_key 17 | secret_key = var.aws_secret_key 18 | } 19 | 20 | resource "aws_security_group" "sg_aula" { 21 | name_prefix = "sg_aula" 22 | 23 | # ssh 24 | ingress { 25 | from_port = 22 26 | to_port = 22 27 | protocol = "tcp" 28 | cidr_blocks = ["0.0.0.0/0"] 29 | } 30 | 31 | # app (docker) 32 | ingress { 33 | from_port = 8001 34 | to_port = 8001 35 | protocol = "tcp" 36 | cidr_blocks = ["0.0.0.0/0"] 37 | } 38 | 39 | # app (docker) 40 | ingress { 41 | from_port = 8080 42 | to_port = 8080 43 | protocol = "tcp" 44 | cidr_blocks = ["0.0.0.0/0"] 45 | } 46 | 47 | # app (direto) 48 | ingress { 49 | from_port = 30001 50 | to_port = 30001 51 | protocol = "tcp" 52 | cidr_blocks = ["0.0.0.0/0"] 53 | } 54 | 55 | # kafka control center 56 | ingress { 57 | from_port = 9021 58 | to_port = 9021 59 | protocol = "tcp" 60 | cidr_blocks = ["0.0.0.0/0"] 61 | } 62 | 63 | # rabbit 64 | ingress { 65 | from_port = 15672 66 | to_port = 15672 67 | protocol = "tcp" 68 | cidr_blocks = ["0.0.0.0/0"] 69 | } 70 | 71 | egress { 72 | from_port = 0 73 | to_port = 0 74 | protocol = "-1" 75 | cidr_blocks = ["0.0.0.0/0"] 76 | } 77 | 78 | # Tags 79 | tags = { 80 | Name = "aula" 81 | } 82 | 83 | } 84 | 85 | # Cria uma instância EC2 86 | resource "aws_instance" "ec_aula" { 87 | ami = "ami-007855ac798b5175e" # ubuntu 22 88 | instance_type = "t2.medium" 89 | key_name = var.aws_keypair 90 | vpc_security_group_ids = [aws_security_group.sg_aula.id] 91 | 92 | # Tags 93 | tags = { 94 | Name = "aula" 95 | } 96 | 97 | # Configura o script de inicialização 98 | user_data = <<-EOF 99 | #!/bin/bash 100 | # Instalando pacotes 101 | sudo apt-get update 102 | sudo apt-get install -y docker.io openjdk-11-jdk docker-compose apache2-utils 103 | 104 | # Instalando Minikube 105 | curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 \ 106 | && chmod +x minikube \ 107 | && sudo mv minikube /usr/local/bin/ 108 | 109 | # Instalando kubectl 110 | sudo apt-get update && sudo apt-get install -y apt-transport-https gnupg2 111 | curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add - 112 | echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list 113 | sudo apt-get update 114 | sudo apt-get install -y kubectl 115 | 116 | # Instalando Bash Completion 117 | sudo apt-get install -y bash-completion 118 | 119 | # Instaçando CCM 120 | export LC_ALL=C 121 | sudo apt install -y python2-minimal 122 | curl https://bootstrap.pypa.io/pip/2.7/get-pip.py --output get-pip.py 123 | python2 get-pip.py 124 | sudo pip install cql PyYAML psutil ccm 125 | 126 | # Inclui o usuário ubuntu ao grupo do docker 127 | sudo usermod -aG docker ubuntu 128 | 129 | # Reinicia o serviço Docker 130 | sudo systemctl restart docker 131 | EOF 132 | 133 | } 134 | 135 | output "public_dns" { 136 | value = aws_instance.ec_aula.public_dns 137 | } 138 | 139 | output "instance_id" { 140 | value = aws_instance.ec_aula.id 141 | } 142 | 143 | output "ssh_user" { 144 | value = "ubuntu" 145 | } 146 | 147 | output "ssh_command" { 148 | value = "ssh -i ubuntu@${aws_instance.ec_aula.public_dns}" 149 | } -------------------------------------------------------------------------------- /doctos/aws.md: -------------------------------------------------------------------------------- 1 | # Criando conta na AWS 2 | 3 | 1. Acesse o site da AWS em https://aws.amazon.com/pt/ 4 | 2. Clique no botão "Criar uma conta gratuita" na parte superior direita da tela 5 | 3. Preencha as informações solicitadas, como nome, sobrenome, endereço de e-mail e senha 6 | 4. Selecione o tipo de conta desejado, que pode ser Pessoal ou Empresarial 7 | 5. Preencha as informações de pagamento, caso necessário 8 | 6. Selecione o plano gratuito, que oferece recursos limitados por um período de 12 meses 9 | 7. Clique no botão "Criar uma conta e entrar no console" 10 | 8. Aguarde a confirmação de criação da conta, que será enviada para o endereço de e-mail cadastrado 11 | 9. Acesse o console da AWS com as credenciais cadastradas e comece a explorar os serviços oferecidos. 12 | 13 | Lembrando que, mesmo que a conta seja gratuita, alguns serviços da AWS podem gerar custos, portanto, é importante estar atento aos valores cobrados e ao uso dos recursos disponíveis. 14 | 15 | 16 | # Criando as chaves de acesso 17 | 18 | A Access Key é usada para acessar os serviços da AWS via API ou linha de comando. As Access Keys são compostas por duas partes, uma chave de acesso (Access Key ID) e uma chave secreta (Secret Access Key). As duas partes são necessárias para autenticação, e elas são usadas para identificar e verificar a permissão de acesso do usuário aos serviços da AWS. 19 | 20 | 1. Faça login na sua conta da AWS em https://aws.amazon.com/pt/ 21 | 2. Clique no seu nome de usuário na parte superior direita da tela e selecione "My Security Credentials" 22 | 3. Na aba "Access keys (chaves de acesso)", clique no botão "Create New Access Key" 23 | 4. Será exibida uma mensagem com as credenciais de acesso, incluindo o Access Key ID e o Secret Access Key. Copie essas informações e salve em um local seguro, pois serão necessárias para configurar a autenticação nos seus Terraforms. 24 | 5. É importante lembrar que o Secret Access Key é confidencial e deve ser tratado com cuidado, pois ele permite o acesso aos seus recursos na AWS. Nunca compartilhe essa informação com terceiros e, em caso de perda ou comprometimento da chave, crie uma nova imediatamente. 25 | 26 | # Criando uma key pair 27 | 28 | A Key Pair é usada para acessar instâncias do Amazon EC2 de forma segura, ela consiste em duas partes: uma chave pública que é armazenada no servidor e uma chave privada que é armazenada localmente. Essa chave é usada para autenticar o usuário ao se conectar a uma instância do EC2. 29 | 30 | 1. Acesse o Console da AWS e selecione o serviço "EC2". 31 | 2. Clique em "Key Pairs" no menu lateral esquerdo. 32 | 3. Clique em "Create Key Pair". 33 | 4. Digite um nome para a Key Pair e selecione o formato de arquivo que você deseja salvar a chave. 34 | 5. Clique em "Create Key Pair". 35 | 6. O arquivo de chave privada será baixado automaticamente, salve-o em um local seguro. A chave privada é necessária para acessar as instâncias EC2. -------------------------------------------------------------------------------- /doctos/terraform.md: -------------------------------------------------------------------------------- 1 | # Instalando terraform 2 | 3 | Você pode seguir as intruções de instação mais detalhadas no [site](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli) do projeto as instruções. 4 | 5 | ## Windows 6 | 7 | 1. Baixe o instalador do Terraform no site oficial: [https://www.terraform.io/downloads.html](https://www.terraform.io/downloads.html) 8 | 2. Extraia o arquivo ZIP baixado para uma pasta de sua escolha. 9 | 3. Adicione o caminho completo do executável do Terraform (terraform.exe) ao PATH do sistema. 10 | 11 | ## Linux 12 | 13 | Abra o terminal e execute o seguinte comando para baixar o pacote do Terraform: 14 | 15 | ``` 16 | wget https://releases.hashicorp.com/terraform/1.0.9/terraform_1.0.9_linux_amd64.zip 17 | ``` 18 | 19 | Descompacte o arquivo ZIP baixado: 20 | 21 | ``` 22 | unzip terraform_1.0.9_linux_amd64.zip 23 | ``` 24 | 25 | Mova o executável do Terraform para uma pasta no PATH do sistema: 26 | 27 | ``` 28 | sudo mv terraform /usr/local/bin/ 29 | ``` -------------------------------------------------------------------------------- /local-vagrant/README.md: -------------------------------------------------------------------------------- 1 | # hands-on-microservices 2 | 3 | O Vagrant é uma ferramenta de linha de comando que permite criar e gerenciar ambientes de desenvolvimento virtualizados. Ele automatiza o processo de criação, configuração e provisionamento de máquinas virtuais, facilitando o trabalho de desenvolvedores e equipes de desenvolvimento que precisam criar ambientes de desenvolvimento padronizados e replicáveis. Com o Vagrant, é possível criar máquinas virtuais em diferentes provedores de virtualização, como VirtualBox, VMware e AWS. O Vagrant é especialmente útil para projetos que exigem ambientes de desenvolvimento complexos, como aplicações web e bancos de dados, pois permite criar, compartilhar e gerenciar esses ambientes de forma fácil e eficiente. 4 | 5 | O primeiro passo é você instalar [vagrant](https://www.vagrantup.com/) ([instalação de vagrant no windows](https://nandovieira.com.br/usando-o-vagrant-como-ambiente-de-desenvolvimento-no-windows)) e [virtualbox](https://www.virtualbox.org/). 6 | 7 | ## Criando o ambiente de testes 8 | 9 | Uma vez o vagrant instalado, faça o clone desse projeto: 10 | 11 | ``` 12 | git clone https://github.com/luizroos/hands-on-microservices 13 | ``` 14 | 15 | Acesse o diretório local-vagrant e execute: 16 | 17 | ``` 18 | vagrant up 19 | ``` 20 | 21 | Aguarde a instalação e configuração da máquina virtual e então logue nela com: 22 | 23 | ``` 24 | vagrant ssh 25 | ``` 26 | 27 | Para sair da máquina virtual, execute 28 | 29 | ``` 30 | exit 31 | ``` 32 | 33 | Para remover a máquina virtual (dentro do host): 34 | 35 | ``` 36 | vagrant destroy 37 | ``` 38 | 39 | Se não for instalar o vagrant e quiser subir um ubuntu direto no virtualbox, veja o aqruivo [bootstrap.sh](local-vagrant/bootstrap.sh) com os comandos que você precisa executar para instalar todas dependências. -------------------------------------------------------------------------------- /local-vagrant/Vagrantfile: -------------------------------------------------------------------------------- 1 | Vagrant.configure("2") do |config| 2 | config.vm.box = "bento/ubuntu-20.04" 3 | config.vm.network "private_network", ip: "192.168.56.32" 4 | config.vm.network "forwarded_port", guest: 8001, host: 8001, autocorrect: true 5 | config.vm.network "forwarded_port", guest: 8080, host: 8080, autocorrect: true 6 | config.vm.network "forwarded_port", guest: 30001, host: 30001, autocorrect: true 7 | config.vm.network "forwarded_port", guest: 9021, host: 9021, autocorrect: true 8 | config.vm.network "forwarded_port", guest: 15672, host: 15672, autocorrect: true 9 | config.vm.network "forwarded_port", guest: 40123, host: 40123, autocorrect: true 10 | config.vm.network "forwarded_port", guest: 40124, host: 40124, autocorrect: true 11 | config.vm.network "forwarded_port", guest: 40125, host: 40125, autocorrect: true 12 | config.vm.provision "file", source: "bashrc", destination: "~/vm_conf_files/bashrc" 13 | config.vm.provision :shell, path: "bootstrap.sh" 14 | config.vm.provider "virtualbox" do |vb| 15 | vb.gui = false 16 | vb.name = "hands-on-microservices" 17 | vb.memory = "4096" 18 | end 19 | end 20 | -------------------------------------------------------------------------------- /local-vagrant/bashrc: -------------------------------------------------------------------------------- 1 | git_branch() { 2 | git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/(\1)/' 3 | } 4 | 5 | export PS1="\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\] \[\033[00;31m\]\$(git_branch)\[\033[00m\]\$ " 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /local-vagrant/bootstrap.sh: -------------------------------------------------------------------------------- 1 | # instalação do docker 2 | curl -fsSL https://get.docker.com -o get-docker.sh 3 | sudo sh get-docker.sh 4 | sudo usermod -aG docker vagrant 5 | 6 | # instalação docker compose 7 | #sudo curl -L "https://github.com/docker/compose/releases/download/1.28.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose 8 | sudo curl -L "https://github.com/docker/compose/releases/download/v2.4.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose 9 | sudo chmod +x /usr/local/bin/docker-compose 10 | 11 | # instala apache bench 12 | sudo apt-get install -y apache2-utils 13 | 14 | # instalação do java 11 15 | curl -O https://download.java.net/java/GA/jdk11/9/GPL/openjdk-11.0.2_linux-x64_bin.tar.gz 16 | tar zxvf openjdk-11.0.2_linux-x64_bin.tar.gz 17 | sudo mv jdk-11* /usr/local/ 18 | sudo echo "JAVA_HOME=/usr/local/jdk-11.0.2" >> /etc/profile.d/jdk.sh 19 | sudo echo "PATH=\$PATH:\$JAVA_HOME/bin" >> /etc/profile.d/jdk.sh 20 | sudo echo "export JAVA_HOME" >> /etc/profile.d/jdk.sh 21 | rm openjdk-11.0.2_linux-x64_bin.tar.gz 22 | 23 | # # modifica .bashrc 24 | cat /home/vagrant/vm_conf_files/bashrc >> /home/vagrant/.bashrc 25 | 26 | # instala minikube 27 | curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb 28 | sudo dpkg -i minikube_latest_amd64.deb 29 | 30 | # instala o kubectl 31 | curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" 32 | sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl 33 | 34 | # instala bash completion 35 | sudo apt-get install bash-completion 36 | 37 | # kubectl autocompletion 38 | echo 'source <(kubectl completion bash)' >>~/.bashrc 39 | kubectl completion bash >/etc/bash_completion.d/kubectl 40 | 41 | ## instalação do java 8 (necessário para cassandra) 42 | # curl -O https://download.java.net/openjdk/jdk8u41/ri/openjdk-8u41-b04-linux-x64-14_jan_2020.tar.gz 43 | # tar zxvf openjdk-8u41-b04-linux-x64-14_jan_2020.tar.gz 44 | # sudo mv java-se-8* /usr/local/ 45 | # sudo echo "JAVA8_HOME=/usr/local/java-se-8u41-ri" >> /etc/profile.d/jdk.sh 46 | # sudo echo "export JAVA8_HOME" >> /etc/profile.d/jdk.sh 47 | 48 | ## instalação ccm 49 | export LC_ALL=C 50 | sudo apt install -y python2-minimal; 51 | curl https://bootstrap.pypa.io/pip/2.7/get-pip.py --output get-pip.py; 52 | python2 get-pip.py; 53 | sudo pip install cql PyYAML psutil ccm 54 | --------------------------------------------------------------------------------