Configure kubectl para gerenciar dois namespaces com usuários diferentes em um mesmo cluster Kubernetes

1. Introdução

Esse artigo mostra como configurar o kubectl no computador local para gerenciar dois namespaces com usuários diferentes em um mesmo cluster Kubernetes. Esse procedimento assume que a configuração do cluster e do namespace no EKS, bem como a criação dos usuários IAM no AWS, já foi realizada.

Além disso, você precisará também instalar e configurar o kubectl e o AWS CLI no seu computador. Bom, se você já tem todas as ferramentas e pré-requisitos, então mãos à obra.

2. Configurar o AWS credentials 

O primeiro passo é adicionar os usuários IAM ao arquivo de credenciais do AWS. Normalmente esse arquivo fica em %userprofile%\.aws\credentials

Adicione os usuários conforme exemplificado abaixo:

[my-first-user]
aws_access_key_id = ACCESSKEYID01
aws_secret_access_key = somesharesecretacesskey
region=eu-central-1

[my-second-user]
aws_access_key_id = ACCESSKEYID02
aws_secret_access_key = anothersharesecretacesskey
region=eu-central-1

Os nomes entre “[ ]” são apelidos (alias) para os seus usuários do AWS. Você pode escolher o nome que melhor lhe convir.

Da mesma forma, a Access Key ID e Secret Access Key de cada usuário dependem do seu ambiente, portanto se você não tiver essas informações, verifique-as com o seu administrador do AWS.

Finalmente, a região depende de onde o cluster EKS foi configurado no seu ambiente. Novamente, verifique isso com o administrador do cluster e faça os ajustes necessários para o seu ambiente. 

3. Configurar o primeiro namespace no kubectl

Abra um novo prompt de comando e configure uma variável de ambiente para referir ao primeiro usuário AWS.

PS> $env:AWS_PROFILE="my-first-user"

Você pode executar o seguinte comando para verificar que o usuário foi configurado e assumido corretamente pelo prompt de comando. Se tudo estiver configurado corretamente você deve ver a Access Key ID do usuário que você configurou no arquivo credentials, bem como outras informações do usuário obtidas no AWS.

PS> aws sts get-caller-identity
{
  "UserId": "ACCESSKEYID01",
  "Account": "999999999999",
  "Arn": "arn:aws:iam::430423143424:user/my-eks-user-1"
}

Agora vamos adicionar o cluster EKS ao kubectl com o seguinte comando:

PS> aws eks update-kubeconfig --region eu-central-1 --name my-eks-cluster-name

Note que no comando acima o parâmetro --name deve referir ao nome do cluster no seu ambiente AWS. Neste caso não é necessário utilizar o ARN do cluster, apenas o nome é suficiente.

Execute o seguinte comando para verificar que o contexto foi adicionado no kubectl:

PS> kubectl config get-contexts

Você deve ver o contexto que acabou de adicionar. Note que o campo NAMESPACE ainda está em branco. Nós vamos agora modificar isso, e ajustar algumas configurações do contexto:

CURRENTNAMECLUSTERAUTHINFONAMESPACE
*arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namearn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namearn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name

Conforme comentamos, dado que há múltiplos namespaces configurados sob o mesmo cluster, vamos executar o comando abaixo para definir o nome do namespace a que esse contexto se refere. O nome do namespace já foi definido durante a configuração do cluster EKS, portanto, certifique-se do nome referente ao seu ambiente.

Além disso, vamos usar o parâmetro --user para definir um alias para o usuário que o kubectl utilizará para gerenciar esse contexto. 

PS> kubectl config set-context --current --namespace my-namespace1 --user my-eks-user-1

Agora, ao executar o comando kubectl config get-contexts, devemos ver as alterações que acabamos de executar:

CURRENTNAMECLUSTERAUTHINFONAMESPACE
*arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namearn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namemy-eks-user-1 my-namespace1

Para facilitar o gerenciamento desse contexto no futuro, vamos também alterar o nome do contexto. Para isso, execute o seguinte comando:

PS> kubectl config rename-context arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name first-context

Os parâmetros utilizados nesse comando são o nome atual do contexto ( arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name ) e o nome desejado (ou seja, first-context). Ajuste esses nomes de acordo com sua necessidade.

Ótimo, agora ao executar kubectl config get-contexts novamente, as configurações do contexto devem ser parecidas com essa:

CURRENTNAMECLUSTERAUTHINFONAMESPACE
* first-contextarn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namemy-eks-user-1 my-namespace1

4. Adicionar o segundo contexto

Para adicionar o segundo contexto, vamos basicamente repetir os passos que executamos para adicionar o primeiro contexto. Por isso, vou cobrir isso de mais resumidamente nessa seção. Configure a variável de ambiente referente ao segundo usuário AWS.

PS> $env:AWS_PROFILE="my-second-user"

Execute novamente o comando para adicionar o cluster EKS. Isso vai adicionar uma nova entrada no arquivo de configuração do kubectl.

PS> aws eks update-kubeconfig --region eu-central-1 --name my-eks-cluster-name

Updated context arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name in C:\Users\User1.kube\config

Modifique as configurações do contexto para definir o namespace e o alias do usuário que o kubectl utilizará para gerenciar esse contexto e, finalmente, renomeie o contexto:

PS> kubectl config set-context --current --namespace my-namespace2 --user my-eks-user-2

PS> kubectl config rename-context arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name second-context

Agora o comando kubectl config get-contexts deve mostrar os dois contextos configurados no seu ambiente:

CURRENTNAMECLUSTERAUTHINFONAMESPACE
* first-contextarn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namemy-eks-user-1 my-namespace1
second-contextarn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-namemy-eks-user-2my-namespace2

5. Ajustar usuários no kubectl

O último passo é ajustar os usuários no arquivo de configuração do kubectl. O arquivo de configuração do kubectl contém os clusters, contextos e usuários configurados no kubectl. 

O arquivo de configuração do kubectl usa a sintaxe YAML, portanto tome muito cuidado com a identação das linhas. Normalmente o arquivo fica armazenado em %userprofile%\.kube\conf. Abra esse arquivo com um editor de texto como o Notepad ou Notepad++.

Conforme destacado na figura abaixo, o arquivo de configuração do kubectl tem três entradas principais: clusters, contexts e users.

A seção contexts: contém uma entrada para cada contexto que adicionamos nos passos 2 e 3. Além disso, cada entrada de contexto contém o nome do usuário correspondente que definimos nos passos 2 e 3.

A seção users: contém os usuários que utilizamos durante a configuração do cluster. É possível notar que essa seção contém apenas 1 usuário. Além disso, o nome do usuário definido na seção users: (“arn:aws:eks:eu-central-1:999999999999:cluster/my-eks-cluster-name”), difere dos nomes dos usuários que definimos nos passos anteriores (“my-eks-user-1” e “my-eks-user-2”).

Texto que mostra um arquivo de configuração do kubectl

O primeiro passo, portanto, é adicionar um novo usuário na seção users:. Conforme ilustrado abaixo, copie todo o conteúdo a partir da linha name: até a linha value: e cole no final do arquivo.

Em seguida, modifique o valor do parâmetro name: nos dois usuários para que correspondam ao nome dos usuários que definimos nos passos 2 e 3 (ou seja, my-eks-user-1 e my-eks-user-2). 

Finalmente, modique o valor do parâmetro value: dos usuários para que correspondam ao valor do alias dos usuários AWS definidos no arquivo %userprofile%\.aws\credentials, e que usamos nas variáveis de ambiente nos passos 2 e 3 (ou seja, my-first-user e my-second-user).

O arquivo deve ficar parecido com a imagem à esquerda:

Finalmente, volte ao prompt de comando e execute o seguinte comando para listar os recursos existentes no namespace:

PS> kubectl get pods

How to update all Chocolatey packages except one

To update all packages installed with Chocolatey use:

choco upgrade all -y

To prevent Chocolatey to update one or more specific packages, we can pin a given package to a specific version. To do so, use:

choco pin add -n <package name> --version <version>

If you wanna to update the package afterwards, you will have to remove the pinned package. To do so, run the following command:

choco pin remove --name <package name>

Then you can run the following command to update the package to a specific version:

choco update <package name> --version=<VALUE>

Alternatively, it is possible to use the “–except” switch to ignore some specific packages. To do so, use the following command:

choco upgrade all -Y --except="package1,pa=ckage2"

Armazenar hosts do mRemoteNG no Microsoft SQL Server

Esse artigo demonstra como configurar o mRemoteNG para armzenar os dados de servidores num banco de dados Microsoft SQL Server, ao invés de usar um arquivo xml padrão. Para isso é necessário instalar os seguintes seoftwares:

  • mRemoteNG. LINK
  • Microsoft SQL Server (qualquer versão. No meu caso estou usando o MS SQL Server 2017 Express Edition) LINK
  • Instale também o Management Studio. LINK

Primeiramente instale o MS SQL Server e o Management Studio. Se você já tem um servidor remoto com MS SQL Server, pode pular essa parte.

No seu servidor onde o SQL Server está instalado, abra o Management Studio e crie um novo banco de dados denominado mRemoteNG.

Navegue em Security, clique com o botão direito em Logins e selecione new login.

  • Na guia “General”:
    • Em login name insira mRemoteNG
    • Selecione SQL Server authentication e insira um password para o usuário.
    • Em ‘default database’ selecione mRemoteNG.
  • Na guia “User Mapping”:
    • No painel “Users mapped to this login“, selecione e habilite o usuário “mRemoteNG”
    • Então, no painel inferior “Database role membership for: mRemoteNG“, selecione a opção “db_owner“.
    • Clique em “Ok“.

Se estiver usando o “SQL Server Express” com “SQL Server Authentication” é necessário também habilitar autenticação mista do SQL.

Para isso clique com o botão direito na instância e selecione “Propriedades”. Em seguida selecione “Security” e então “SQL Server and Windows Authentication Mode”.

Execute o seguinte código para configurar as tabelas necessárias na database:

if exists (select * from dbo.sysobjects
        where id = object_id(N'[dbo].[tblCons]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[tblCons]
GO

if exists (select * from dbo.sysobjects
        where id = object_id(N'[dbo].[tblRoot]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[tblRoot]
GO

if exists (select * from dbo.sysobjects
        where id = object_id(N'[dbo].[tblUpdate]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[tblUpdate]
GO

CREATE TABLE [dbo].[tblCons] (
           [ID] int NOT NULL IDENTITY(1,1),
           [ConstantID] varchar(128) NOT NULL PRIMARY KEY,
           [PositionID] int NOT NULL,
           [ParentID] varchar(128),
           [LastChange] datetime NOT NULL,
           [Name] varchar(128) NOT NULL,
           [Type] varchar(32) NOT NULL,
           [Expanded] bit NOT NULL,
           [AutomaticResize] bit DEFAULT ((1)) NOT NULL,
           [CacheBitmaps] bit NOT NULL,
           [Colors] varchar(32) NOT NULL,
           [ConnectToConsole] bit NOT NULL,
           [Connected] bit NOT NULL,
           [Description] varchar(1024),
           [DisableCursorBlinking] bit NOT NULL,
           [DisableCursorShadow] bit NOT NULL,
           [DisableFullWindowDrag] bit NOT NULL,
           [DisableMenuAnimations] bit NOT NULL,
           [DisplayThemes] bit NOT NULL,
           [DisplayWallpaper] bit NOT NULL,
           [Domain] varchar(512),
           [EnableDesktopComposition] bit NOT NULL,
           [EnableFontSmoothing] bit NOT NULL,
           [ExtApp] varchar(256),
           [Favorite] tinyint NOT NULL,
           [Hostname] varchar(512),
           [ICAEncryptionStrength] varchar(32) NOT NULL,
           [Icon] varchar(128) NOT NULL,
           [LoadBalanceInfo] varchar(1024),
           [MacAddress] varchar(32),
           [Panel] varchar(128) NOT NULL,
           [Password] varchar(1024),
           [Port] int NOT NULL,
           [PostExtApp] varchar(256),
           [PreExtApp] varchar(256),
           [Protocol] varchar(32) NOT NULL,
           [PuttySession] varchar(128),
           [RDGatewayDomain] varchar(512),
           [RDGatewayHostname] varchar(512),
           [RDGatewayPassword] varchar(1024),
           [RDGatewayUsageMethod] varchar(32) NOT NULL,
           [RDGatewayUseConnectionCredentials] varchar(32) NOT NULL,
           [RDGatewayUsername] varchar(512),
           [RDPAlertIdleTimeout] bit NOT NULL,
           [RDPAuthenticationLevel] varchar(32) NOT NULL,
           [RDPMinutesToIdleTimeout] int NOT NULL,
           [RdpVersion] varchar(10),
           [RedirectAudioCapture] bit NOT NULL,
           [RedirectClipboard] bit DEFAULT ((0)) NOT NULL,
           [RedirectDiskDrives] bit NOT NULL,
           [RedirectKeys] bit NOT NULL,
           [RedirectPorts] bit NOT NULL,
           [RedirectPrinters] bit NOT NULL,
           [RedirectSmartCards] bit NOT NULL,
           [RedirectSound] varchar(64) NOT NULL,
           [RenderingEngine] varchar(10),
           [Resolution] varchar(32) NOT NULL,
           [SSHOptions] varchar(1024) NOT NULL,
           [SSHTunnelConnectionName] varchar(128) NOT NULL,
           [SoundQuality] varchar(20) NOT NULL,
           [UseCredSsp] bit NOT NULL,
           [UseEnhancedMode] bit DEFAULT ((0)),
           [UseVmId] bit,
           [UserField] varchar(256),
           [Username] varchar(512),
           [VNCAuthMode] varchar(10),
           [VNCColors] varchar(10),
           [VNCCompression] varchar(10),
           [VNCEncoding] varchar(20),
           [VNCProxyIP] varchar(128),
           [VNCProxyPassword] varchar(1024),
           [VNCProxyPort] int,
           [VNCProxyType] varchar(20),
           [VNCProxyUsername] varchar(512),
           [VNCSmartSizeMode] varchar(20),
           [VNCViewOnly] bit NOT NULL,
           [VmId] varchar(100),
           [InheritAutomaticResize] bit DEFAULT ((0)) NOT NULL,
           [InheritCacheBitmaps] bit NOT NULL,
           [InheritColors] bit NOT NULL,
           [InheritDescription] bit NOT NULL,
           [InheritDisableCursorBlinking] bit NOT NULL,
           [InheritDisableCursorShadow] bit NOT NULL,
           [InheritDisableFullWindowDrag] bit NOT NULL,
           [InheritDisableMenuAnimations] bit NOT NULL,
           [InheritDisplayThemes] bit NOT NULL,
           [InheritDisplayWallpaper] bit NOT NULL,
           [InheritDomain] bit NOT NULL,
           [InheritEnableDesktopComposition] bit NOT NULL,
           [InheritEnableFontSmoothing] bit NOT NULL,
           [InheritExtApp] bit NOT NULL,
           [InheritFavorite] bit NOT NULL,
           [InheritICAEncryptionStrength] bit NOT NULL,
           [InheritIcon] bit NOT NULL,
           [InheritLoadBalanceInfo] bit DEFAULT ((0)) NOT NULL,
           [InheritMacAddress] bit NOT NULL,
           [InheritPanel] bit NOT NULL,
           [InheritPassword] bit NOT NULL,
           [InheritPort] bit NOT NULL,
           [InheritPostExtApp] bit NOT NULL,
           [InheritPreExtApp] bit NOT NULL,
           [InheritProtocol] bit NOT NULL,
           [InheritPuttySession] bit NOT NULL,
           [InheritRDGatewayDomain] bit NOT NULL,
           [InheritRDGatewayHostname] bit NOT NULL,
           [InheritRDGatewayPassword] bit NOT NULL,
           [InheritRDGatewayUsageMethod] bit NOT NULL,
           [InheritRDGatewayUseConnectionCredentials] bit NOT NULL,
           [InheritRDGatewayUsername] bit NOT NULL,
           [InheritRDPAlertIdleTimeout] bit NOT NULL,
           [InheritRDPAuthenticationLevel] bit NOT NULL,
           [InheritRDPMinutesToIdleTimeout] bit NOT NULL,
           [InheritRdpVersion] bit DEFAULT ((0)) NOT NULL,
           [InheritRedirectAudioCapture] bit NOT NULL,
           [InheritRedirectClipboard] bit DEFAULT ((0)) NOT NULL,
           [InheritRedirectDiskDrives] bit NOT NULL,
           [InheritRedirectKeys] bit NOT NULL,
           [InheritRedirectPorts] bit NOT NULL,
           [InheritRedirectPrinters] bit NOT NULL,
           [InheritRedirectSmartCards] bit NOT NULL,
           [InheritRedirectSound] bit NOT NULL,
           [InheritRenderingEngine] bit NOT NULL,
           [InheritResolution] bit NOT NULL,
           [InheritSSHOptions] bit NOT NULL,
           [InheritSSHTunnelConnectionName] bit NOT NULL,
           [InheritSoundQuality] bit NOT NULL,
           [InheritUseConsoleSession] bit NOT NULL,
           [InheritUseCredSsp] bit NOT NULL,
           [InheritUseEnhancedMode] bit DEFAULT ((0)),
           [InheritUseVmId] bit,
           [InheritUserField] bit NOT NULL,
           [InheritUsername] bit NOT NULL,
           [InheritVNCAuthMode] bit NOT NULL,
           [InheritVNCColors] bit NOT NULL,
           [InheritVNCCompression] bit NOT NULL,
           [InheritVNCEncoding] bit NOT NULL,
           [InheritVNCProxyIP] bit NOT NULL,
           [InheritVNCProxyPassword] bit NOT NULL,
           [InheritVNCProxyPort] bit NOT NULL,
           [InheritVNCProxyType] bit NOT NULL,
           [InheritVNCProxyUsername] bit NOT NULL,
           [InheritVNCSmartSizeMode] bit NOT NULL,
           [InheritVNCViewOnly] bit NOT NULL,
           [InheritVmId] bit
) ON [PRIMARY]
GO

CREATE TABLE [dbo].[tblRoot] (
           [Name] [varchar] (2048) NOT NULL ,
           [Export] [bit] NOT NULL ,
           [Protected] [varchar] (4048) NOT NULL ,
           [ConfVersion] [float] NOT NULL
) ON [PRIMARY]
GO

CREATE TABLE [dbo].[tblUpdate] (
           [LastUpdate] [datetime] NULL
) ON [PRIMARY]
GO

No mRemoteNG vá em Tools > Options.

Na tela “mRemoteNG Options” selecione “SQL Server” e habilite “Use SQL Server to load & save connections”.

Em hostname informe o hostname do servidor e o nome da instância (e.g.: MyComputer\SQLEXPRESS).

No meu caso tanto o SQL Server quanto o mRemoteNG estão instalados no mesmo computador, por isso estou usando um ponto ao invés do nome do computador.

Informe o nome da database e as credenciais de acesso que acabou de configurar e clique em “Test connection”

O Active Directory virou uma pedra no sapato da Microsoft?

O maior trunfo da Microsoft no mercado corporativo nos últimos vinte anos se tornou a sua pedra no sapato. Estou falando dele, o Active Directory.

Por muitos anos redes corporativas foram sustentadas por essa solução ubíqua e sem rival. Alguns, nostalgicamente poderão falar das maravilhas do Novel ou outros padrões dos anos 90, mas o fato é que o Active Directory reinou soberano no mundo corporativo desde que surgiu em meados dos anos 90 e é, por assim dizer, sinônimo de “rede” para muitos profissionais da área de TI. Afinal, quem nunca precisou mudar a senha do seu “usuario de rede”?

Resumidamente, o Active Directory é um banco de dados distribuído e organizado em domínios. Cada domínio contém objetos que representam diversos recursos de uma rede de computadores específica.

Através do Active Directory, administradores de sistemas podem fazer a gestão desses recursos de forma centralizada, limitando o acesso a recursos dessa rede apenas a quem pertence ao domínio ou definindo permissões para usuários ou computadores e, repito, tudo isso de forma centralizada

A facilidade de gerir a segurança através do Active Directory fez muitas empresas optarem por pagar mais caro no sistema operacional Windows ao invés de usar o bom e velho (e gratuito) Linux. O Linux, é preciso dizer, nunca foi capaz de se integrar adequadamente ao Active Directory, apesar do esforço de algumas distribuições em implementar essa funcionalidade. 

No entanto, o paradigma da computação em nuvem parece querer desestabilizar o reinado do Active Directory. 

Explico: nesses tempos líquidos, a criação e destruição de servidores virtuais numa nuvem pública ocorre numa velocidade vertiginosa. Servidores são lançados em auto scaling groups para atender a demanda por recursos em momentos específicos e destruídos tão logo não sejam mais necessários para diminuir custos. Uma aplicação web pode, facilmente, adicionar 20 novos servidores antes do café da manhã e excluir todos eles antes do almoço. 

Neste sentido, a velocidade em lançar um clone do servidor é fundamental para garantir a responsividade da aplicação. É evidente, portanto, que o tempo despendido para conectar esses servidores a um domínio é inútil e prejudicial para os negócios.

Alëm disso, esse cenário tende a aumentar o tempo de manutenção ou profilaxia do domínio –  sem falar dos custos com replicação e armazenamento dos dados do Active Directory relacionados com esses servidores “temporários” e que, a rigor, são totalmente desnecessários.

Você pode estar pensando: Oras, para isso basta não adicionar o servidor Windows ao domínio. 

Ao tirar o Active Directory da equação a responsabilidade pela segurança fica a cargo da própria aplicação, que agora precisa autenticar e autorizar usuários. Isso é feito através de padrões e ferramentas como certificados de segurança, tokens de autenticação ou provedores de identidade federados. E tudo isso é suportado tanto pelo Windows quanto por distribuições Linux.

O ponto é que, uma vez que o Active Directory na nuvem mais atrapalha do que ajuda, sua implementação não faz sentido. Mas, se não vou adicionar um servidor ao domínio, porque eu deveria pagar mais caro num sistema operacional que, agora, não trás nenhuma outra vantagem?

Além disso, na medida em que as aplicações usarem menos a autenticação do Windows (suportada por Active Directory) o uso de outras ferramentas da Microsoft passa a ser questionável: sem autenticação do Windows, qual a vantagem de pagar caro numa instalação do Microsoft SQL Server, se posso usar o MySQL gratuito e  – agora – tão seguro quanto? E se posso instalar o MySQL num servidor Linux com as mesmas vantagens (do ponto de vista de autenticação) que num Windows, porque deveria pagar pela licença do sistema operacional? 

Bom, esse é apenas um exercício de futurologia e, longe de mim querer decretar o fim do WIndows ou a morte da MIcrosoft. No entanto, considerando a empresa como um player relevante no mercado de computação em nuvem, penso que seu posicionamento com relação ao Active Directory na nuvem será determinante para o futuro da plataforma, da empresa e, até mesmo, da computação em nuvem.

Automatizar deploy com o GitHub Actions

O GitHub Actions é uma ferramenta de CI/CD integrada ao GitHub que pode ajudar a automatizar o deploy de sites e códigos publicados na plataforma.

Esse procedimento vai mostrar como ativar o Actions e configurar um workflow para fazer o deploy via FTP de um website.


Continuar lendo Automatizar deploy com o GitHub Actions