DEV Community: Álvaro F. P. P."

Como criar um repositório para gestão de recursos do GitHub com o Pulumi

Álvaro F. P. P." — Sun, 06 Apr 2025 15:01:06 +0000

🇺🇸 To read in English: How to create a GitHub resource management repository with Pulumi.

Gerenciar infraestrutura como código (IaC, Infrastructure as Code) se tornou uma prática essencial para equipes de desenvolvimento modernas, e o Pulumi surge como uma ferramenta poderosa nesse cenário, permitindo definir recursos em linguagens de programação que você já conhece - seja Python, JavaScript, TypeScript, Go ou C#.

Se você já utiliza o GitHub para controle de versão e colaboração, talvez esteja se perguntando como integrar seus recursos existentes (repositórios, organizações, membros, etc) ao fluxo de trabalho do Pulumi. A boa notícia é que o Pulumi oferece mecanismos para importar e gerenciar esses recursos, permitindo que você aproveite a infraestrutura existente sem precisar recriá-la do zero.

Nesta postagem, vamos explorar o processo de criar um repositório que nos permita gerenciar recursos do GitHub, desde repositórios individuais até estruturas organizacionais (quase) completas.

Motivação

No meu caso, a minha principal motivação é a minha bagunça. Atualmente tenho 126 repositórios pessoais na minha conta do GitHub, além de fazer parte de 14 organizações, dos quais alguns eu sou o responsável pela parte de Ops. Fazer a gestão de acessos, licenças, workflows, entre outras coisas vem se tornando uma tarefa bastante onerosa.

Além disso, no último semestre tenho trabalhado diariamente com o AWS CDK (Cloud Development Kit), uma ferramenta da AWS que permite definir infraestrutura na nuvem usando linguagens de programação como TypeScript. Comparado com os anos que trabalhei com Terraform, que utiliza HCL (HashiCorp Configuration Language), uma linguagem declarativa específica para definir infraestrutura como código, posso afirmar que tenho gostado muito mais de usar uma linguagem de programação convencional para gerir a infraestrutura do que o HCL.

Sendo assim, o Pulumi se apresentou como uma ótima opção de uso. Ele me permite reutilizar minha estrutura para projetos em TypeScript (como linter, CI/CD, etc), resolve meu problema de gestão de infraestrutura e possibilita descrever cenários mais dinâmicamente do que antes (creio que uma das principais vantagens de se usar uma linguagem de programação para isso).

Considerações

Antes de prosseguirmos, quero descrever algumas considerações para esse artigo:

Você precisa ter o Pulumi instalado na sua máquina: Download & install Pulumi.
A linguagem de programação que irei utilizar será TypeScript.
Todo o passo a passo será feito em um diretório inicialmente vazio.

Preparando o projeto

Caso não queira fazer o passo a passo dessa seção, você pode usar o meu template:

alvarofpp / template-infra-pulumi

Template for IaC projects using Pulumi.

Template for IaC using Pulumi

This template comes with a structure for you to manage your personal repositories or organizations on GitHub, as well as making it easy to expand to other contexts.

Migrating GitHub resources to Pulumi

You can use the alvarofpp/import-from-github-to-pulumi repository to perform the migration of an organization or your personal repositories to Pulumi.

View on GitHub

Perceba que para cada conta será um diretório com um projeto em TypeScript, com seus próprios arquivos package.json e afins. No meu caso, será um projeto para meus repositórios pessoais e um projeto para cada organização. O passo a passo para preparar o projeto é o mesmo em todos esses casos.

Criando um projeto no Pulumi

Use o login local do Pulumi:
```
pulumi login file:$(pwd)
```
O comando pulumi login é usado para autenticar sua CLI do Pulumi com um backend de armazenamento de estado. Por padrão, você se conecta ao backend gerenciado na nuvem do Pulumi. Quando usamos file:$(pwd), você configura o Pulumi para usar um backend de arquivo local em vez do backend na nuvem.
Inicie um projeto no Pulumi:
```
pulumi new typescript --force
```
Precisamos usar o --force porque o comando login irá criar um diretório home e o comando new exige ser executado em um diretório vazio.
Instale o provedor do GitHub:
```
npm install @pulumi/github
```
Adicione o token do GitHub:
```
pulumi config set github:token <token> --secret
```
Caso não saiba como criar um token de acesso para a API do GitHub, consulte a documentação oficial: Gerenciar seus tokens de acesso pessoal.
Adicione o owner (pode ser um usuário ou uma organização):
```
pulumi config set github:owner <owner>
```

Até aqui o seu diretório deve estar próximo disso:

.
├── Pulumi.main.yaml
├── Pulumi.yaml
├── index.ts
├── package-lock.json
├── package.json
└── tsconfig.json

Tornando o projeto mais dinâmico

Como terei inúmeros recursos, não é interessante ter que usar um esquema de importação convencional, pois implicaria em sempre ter que importar um novo repositório quando criado, além dos mais de 120 repositórios que já tenho. Ao invés disso, optei por importar dinâmicamente os recursos.

O objetivo é ter diretórios para cada tipo de recurso e uma forma dinâmica de importarmos esses recursos.

Crie um arquivo registry.ts com o seguinte conteúdo:

import * as fs from "fs";
import * as path from "path";

import * as pulumi from "@pulumi/pulumi";

export interface RegistryBaseConstructor {
  new (): RegistryBase;
}

export class RegistryBase {
  constructor(suffix: string, directory: string) {
    this.init(suffix, directory)
      .then((ResourceRegistry) => {
        ResourceRegistry.forEach((ResourceClass) => {
          new ResourceClass();
        });
      })
      .catch((error) => {
        pulumi.log.error(`Critical error in init method: ${error}`);
        throw error;
      });
  }

  protected async init(suffix: string, directory: string) {
    const anyResourceRegistry = new Map<string, RegistryBaseConstructor>();
    const classesDir = path.join(directory, "./");
    const files = fs.readdirSync(classesDir);

    await Promise.all(
      files.map(async (file) => {
        if (file.endsWith(".ts") && file !== "index.ts") {
          const className = file.replace(".ts", "") + suffix;
          const modulePath = path.join(classesDir, file);

          try {
            const module = await import(modulePath);
            const Class = module[className];
            if (Class) {
              anyResourceRegistry.set(className, Class);
            }
          } catch (error) {
            console.error(`Failed to register ${className} class:`, error);
          }
        }
      }),
    );

    return anyResourceRegistry;
  }
}

A classe RegistryBase será nossa classe base para as classes que conterão cada tipo de recurso. A função dela é ser um registry de recursos. A busca por esses recursos será dinâmica, atendendo dois critérios:

Os recursos precisam ter um sufixo previamente definido.
Os recursos precisam estar no mesmo diretório que o registry.

Crie o diretório repositories:
```
mkdir repositories
```

Crie o arquivo repositories/index.ts com o seguinte conteúdo:

import { RegistryBase } from "../registry";

export class RepositoriesRegistry extends RegistryBase {
  constructor() {
    super("Repository", __dirname);
  }
}

A classe RepositoriesRegistry irá conter todas as classes que possuem Repository como sufixo e estejam dentro de repositories/.

No arquivo index.ts, importe o RepositoriesRegistry:

import { RepositoriesRegistry } from "./repositories";

const repositories = new RepositoriesRegistry();

❗ Para o caso de organizações, você deve repetir os passos 2 a 4 para memberships (sufixo Membership) e teams (sufixo Team).

Até aqui o seu diretório deve estar parecido com isso:

.
├── Pulumi.main.yaml
├── Pulumi.yaml
├── index.ts
├── memberships
│   └── index.ts
├── package-lock.json
├── package.json
├── repositories
│   └── index.ts
├── teams
│   └── index.ts
└── tsconfig.json

Coletando dados e gerando os recursos no Pulumi

Nós queremos que os recursos sejam os mais fidedignos do seu estado atual, pois caso não sejam isso pode acarretar em uma atualização não desejada de estado durante a importação ou o uso. Para isso podemos usar a API do GitHub para coletar os dados de cada recurso e declara-los no Pulumi.

Processo manual

Aqui você deverá criar um script para coletar os dados da API do GitHub e atribuí-los aos recursos do Pulumi na linguagem de programação escolhida.

Para repositórios:

Temos duas formas de listar os repositórios:
- Para seus repositórios pessoais: GET /user/repos?affiliation=owner.
- Para os repositórios de uma organização: GET /orgs/<org>/repos.
Itere sobre cada repositório e use os seguintes endpoints para coletar dados mais detalhados:
- GET /repos/<user_or_org>/<repository_name>: para dados gerais sobre o repositório.
- GET /repos/<repository_name>/pages: para dados sobre as páginas do repositório.

Para membros de uma organização:

GET /orgs/<org>/members para listar os membros da organização.
Itere sobre cada membro e faça uma chamada para o endpoint GET /orgs/<org>/memberships/<member> para coletar dados de associação daquele usuário com a organização.

Para times de uma organização:

GET /orgs/<org>/teams para listar os times da organização.
Itere sobre cada time e use os seguintes endpoints para coletar dados mais detalhados:
- GET /orgs/<org>/teams/<team> para dados gerais do time.
- GET /orgs/<org>/teams/<team>/repos para listar os repositórios do time.
- GET /orgs/<org>/teams/<team>/members para listar os membros daquele time. Itere sobre cada membro do time:
  - GET /orgs/<org>/teams/<team>/memberships/<member>

Agora que você tem todos os dados necessários, basta atribuí-los para os respectivos recursos no Pulumi:

Repositório: github.Repository.
- Branch do repositório: github.Branch.
- Branch padrão (para o caso de repositórios não arquivados): github.BranchDefault.
Membros da organização: github.Membership.
Times da organização: github.Team.
- Repositórios do time: github.TeamRepository.
- Para membros do time, você tem duas formas (eu prefiro a primeira por ser mais simples):
  - github.TeamMembers.
  - github.TeamMembership.

Importando usando repositório

Para abstrair todo esse passo a passo de coleta de dados do GitHub e montagem dos recursos do Pulumi que vimos anteriormente, criei o seguinte repositório:

alvarofpp / import-from-github-to-pulumi

Scripts to import resources from organizations and personal projects on GitHub into Pulumi.

Import from GitHub to Pulumi

This repository contains a configured Docker image with scripts to import your personal repositories or repositories, members and teams of an organization into Pulumi.

After running the import script, two sets of artifacts are generated and saved in the resources/:

import_*.txt: files with commands for importing resources.
members/*.ts, repositories/*.ts and teams/*.ts: Pulumi resource files.

The alvarofpp/template-infra-pulumi repository has a directory structure that you can use as a basis.

How to use

This repository can be used for two purposes:

Importing your personal repositories.
Importing members of an organization's repositories and teams.

For both cases, you first need to run make build to generate the Docker image that will be used to run the scripts.

The commands using make that will be shown below can be found in the Makefile file If you choose not to use the Makefile, you can…

View on GitHub

Nesse repositório, você terá uma imagem Docker configurada e com scripts para gerar os arquivos dos recursos para o Pulumi com base nos dados retornados pela a API do GitHub.

Para esse repositório funcionar, você deve ter o Docker e o make instalado na sua máquina. Se você usa Linux, provavelmente já tem o make instalado.

⚠️ Caso você esteja importando contas e organizações em sequência, após cada importação você pode usar o comando make clear para limpar os logs e arquivos gerados durante a importação anterior.

Em um outro diretório, clone o repositório:

git clone git@github.com:alvarofpp/import-from-github-to-pulumi.git

Gerando os arquivos de repositórios pessoais

Exporte o token de acesso ao GitHub:

export GITHUB_ACCESS_TOKEN=github_pat_...

Exporte o seu usuário no GitHub:
```
export GITHUB_USER=...
```
Execute o comando de gerar os arquivos para o Pulumi:
```
make import-my-repos
```
No diretório resources terá os seguintes arquivos:
- import_*.txt: arquivo com os comandos de importação.
- repositories/*.ts: arquivos com os recursos para cada repositório.

Gerando os arquivos de repositórios, membros e times de uma organização

Exporte o token de acesso ao GitHub:

export GITHUB_ACCESS_TOKEN=github_pat_...

Exporte o nome da organização no GitHub:
```
export GITHUB_ORG=...
```
Execute o comando de gerar os arquivos para o Pulumi:
```
make import-org
```
No diretório resources terá os seguintes arquivos:
- import_*.txt: arquivo com os comandos de importação.
- memberships/*.ts: arquivos para cada membro da organização.
- repositories/*.ts: arquivos para cada repositório da organização.
- teams/*.ts: arquivos para cada time da organização.

Importando os recursos

Caso você tenha coletado por conta própria os dados, então também deve montar os comandos de importação, sendo eles:

# Repositório
pulumi import github:index/repository:Repository <resource_name> <repository>

# Branch do repositório
pulumi import github:index/branch:Branch <resource_name> <repositorio>:<branch>

# Membro de organização
pulumi import github:index/membership:Membership <resource_name> <org>:<member>

# Time de organização
pulumi import github:index/team:Team <resource_name> <team_id>

# Membros do time
pulumi import github:index/teamMembers:TeamMembers <resource_name> <team_id>

# Repositório do time
pulumi import github:index/teamRepository:TeamRepository <resource_name> <team_id>:<repository>

Caso você tenha optado por usar o repositório que sugeri anteriormente, o passo a passo é:

Copie os arquivos *.ts para os seus respectivos diretórios do projeto do Pulumi.
Execute todos os comandos nos arquivos import_*.txt.
Agora execute pulumi up e aplique as atualizações, caso haja.

Pronto, a partir de agora você terá um projeto que possibilita gerir seus recursos do GitHub usando o Pulumi. Lembre-se que essa estrutura pode ser expandida para outros tipos de recursos e que você está usando uma linguagem de programação para isso, então automações com scripts funcionam muito bem nesse contexto.

Dicas e sugestões

Perceba que usamos o login local do Pulumi, isso é apenas para facilitar a didática. Em um ambiente real, é preferível que você salve os estados no S3 ou serviço semelhante.
A indentação dos códigos pode não está adequadamente alinhados, mas você pode usar um formatter/linter para consertar isso. No meu caso, uso o do Deno (deno fmt).

Casos de uso

Existem vários casos de uso e isso depende do seu contexto ou do contexto da organização. Aqui irei listar apenas alguns casos de uso que são principalmente uteis para contas pessoais.

Atualização de arquivos especificos

Com o recurso RepositoryFile você consegue gerenciar arquivos especificos nos seus repositórios. Exemplos de arquivos interessantes para usar esse recurso são LICENSE e também workflows. Este último tipo de arquivo (workflows) é bastante útil para contas pessoais, pois o GitHub permite compartilhar actions e workflows em organizações, porém não em contas pessoais.

Atualização de repositórios para ocasiões especiais

Eu possuo alguns repositórios que participam do Hacktoberfest. Portanto pretendo colocar uma verificação de data para que todo início de outubro adicione o tópico hacktoberfest no repositório e em todo início de novembro remova esse tópico.

Gestão de compartilhamentos e acessos

Agora ficou mais fácil definir quais contas fazem parte da sua organização, seus privilégios, quais times tem acessos a quais repositórios, etc.

Gestão de variáveis e segredos

Se você usa o GitHub Actions, deve estar familiarizado com o uso de variáveis e segredos nos seus workflows. Uma boa prática é colocar um tempo de expiração curto em segredos e renova-los sempre que possível. O Pulumi permite que você armazene segredos na stack, o comando de inserir o token do GitHub no projeto é um exemplo disso, portando você pode integrar essa funcionalidade com um script de renovação de token. Toda vez que o script é executado, ele automaticamente atualiza o token na stack e atualiza o segredo no repositório.

How to create a GitHub resource management repository with Pulumi

Álvaro F. P. P." — Sun, 06 Apr 2025 15:00:25 +0000

🇧🇷 Para ler em Português: Como criar um repositório para gestão de recursos do GitHub com o Pulumi.

Managing infrastructure as code (IaC) has become an essential practice for modern development teams, and Pulumi has emerged as a powerful tool in this scenario, allowing you to define resources in programming languages you already know - be it Python, JavaScript, TypeScript, Go or C#.

If you already use GitHub for version control and collaboration, you may be wondering how to integrate your existing resources (repositories, organizations, members, etc.) into Pulumi's workflow. The good news is that Pulumi offers mechanisms for importing and managing these resources, allowing you to take advantage of existing infrastructure without having to recreate it from scratch.

In this post, we'll explore the process of creating a repository that allows us to manage GitHub resources, from individual repositories to (almost) complete organizational structures.

Motivation

In my case, my main motivation is my mess. I currently have 126 personal repositories on my GitHub account, as well as being part of 14 organizations, some of which I'm responsible for Ops. Managing access, licenses, workflows, among other things, has become a very onerous task.

In addition, in the last semester I've been working daily with the AWS CDK (Cloud Development Kit), an AWS tool that allows you to define infrastructure in the cloud using programming languages such as TypeScript. Compared to the years I worked with Terraform, which uses HCL (HashiCorp Configuration Language), a specific declarative language for defining infrastructure as code, I can say that I've enjoyed using a conventional programming language to manage infrastructure much more than HCL.

As such, Pulumi presented itself as a great option to use. It allows me to reuse my structure for TypeScript projects (as a linter, CI/CD, etc.), solves my infrastructure management problem and makes it possible to describe scenarios more dynamically than before (I believe one of the main advantages of using a programming language for this).

Considerations

Before we go any further, I'd like to make a few considerations for this article:

You need to have Pulumi installed on your machine: Download & install Pulumi.
The programming language I will be using is TypeScript.
The entire step-by-step will be done in an initially empty directory.

Preparing the project

If you don't want to do the step-by-step in this section, you can use my template:

alvarofpp / template-infra-pulumi

Template for IaC projects using Pulumi.

Template for IaC using Pulumi

This template comes with a structure for you to manage your personal repositories or organizations on GitHub, as well as making it easy to expand to other contexts.

Migrating GitHub resources to Pulumi

You can use the alvarofpp/import-from-github-to-pulumi repository to perform the migration of an organization or your personal repositories to Pulumi.

View on GitHub

Note that for each account there will be a directory with a TypeScript project, with its own package.json files and the like. In my case, it will be a project for my personal repositories and a project for each organization. The step-by-step process for preparing the project is the same in all these cases.

Creating a project in Pulumi

Use the local Pulumi login:
```
pulumi login file:$(pwd)
```
The pulumi login command is used to authenticate your Pulumi CLI with a stateful storage backend. By default, you connect to the backend managed in the Pulumi cloud. When we use file:$(pwd), you configure Pulumi to use a local file backend instead of the cloud backend.
Start a Pulumi project
```
pulumi new typescript --force
```
We need to use --force because the login command will create a home directory and the new command requires to be run in an empty directory.
Install the GitHub provider:
```
npm install @pulumi/github
```
Add the GitHub token:
```
pulumi config set github:token <token> --secret
```
If you don't know how to create an access token for the GitHub API, consult the official documentation: Managing your personal access tokens.
Add the owner (it can be a user or an organization):
```
pulumi config set github:owner <owner>
```

By now your directory should be close to this:

.
├── Pulumi.main.yaml
├── Pulumi.yaml
├── index.ts
├── package-lock.json
├── package.json
└── tsconfig.json

Making the project more dynamic

As I'm going to have a lot of resources, it's not interesting to have to use a conventional import scheme, as it would mean always having to import a new repository when I create one, in addition to the more than 120 repositories I already have. Instead, I chose to dynamically import the resources.

The aim is to have directories for each type of resource and a dynamic way of importing these resources.

Create a registry.ts file with the following content:

import * as fs from "fs";
import * as path from "path";

import * as pulumi from "@pulumi/pulumi";

export interface RegistryBaseConstructor {
  new (): RegistryBase;
}

export class RegistryBase {
  constructor(suffix: string, directory: string) {
    this.init(suffix, directory)
      .then((ResourceRegistry) => {
        ResourceRegistry.forEach((ResourceClass) => {
          new ResourceClass();
        });
      })
      .catch((error) => {
        pulumi.log.error(`Critical error in init method: ${error}`);
        throw error;
      });
  }

  protected async init(suffix: string, directory: string) {
    const anyResourceRegistry = new Map<string, RegistryBaseConstructor>();
    const classesDir = path.join(directory, "./");
    const files = fs.readdirSync(classesDir);

    await Promise.all(
      files.map(async (file) => {
        if (file.endsWith(".ts") && file !== "index.ts") {
          const className = file.replace(".ts", "") + suffix;
          const modulePath = path.join(classesDir, file);

          try {
            const module = await import(modulePath);
            const Class = module[className];
            if (Class) {
              anyResourceRegistry.set(className, Class);
            }
          } catch (error) {
            console.error(`Failed to register ${className} class:`, error);
          }
        }
      }),
    );

    return anyResourceRegistry;
  }
}

The RegistryBase class will be our base class for the classes that will contain each type of resource. Its function is to be a registry of resources. The search for these resources will be dynamic, meeting two criteria:

The resources must have a previously defined suffix.
The resources must be in the same directory as the registry.

Create the repositories directory:
```
mkdir repositories
```

Create the file repositories/index.ts with the following content:

import { RegistryBase } from "../registry";

export class RepositoriesRegistry extends RegistryBase {
  constructor() {
    super("Repository", __dirname);
  }
}

The RepositoriesRegistry class will contain all the classes that have Repository as a suffix and are inside repositories/.

In the index.ts file, import the RepositoriesRegistry:

import { RepositoriesRegistry } from "./repositories";

const repositories = new RepositoriesRegistry();

❗ For the case of organizations, you must repeat steps 2 to 4 for memberships (suffix Membership) and teams (suffix Team).

So far your directory should look like this:

.
├── Pulumi.main.yaml
├── Pulumi.yaml
├── index.ts
├── memberships
│ └── index.ts
├── package-lock.json
├── package.json
├── repositories
│ └── index.ts
├── teams
│ └── index.ts
└── tsconfig.json

Collecting data and generating resources in Pulumi

We want the resources to be as faithful as possible to their current state, because if they are not, this could lead to an unwanted state update during import or use. To do this, we can use the GitHub API to collect the data for each resource and declare it in Pulumi.

Manual process

Here you must create a script to collect the data from the GitHub API and assign it to Pulumi resources in the programming language of your choice.

For repositories:

We have two ways of listing repositories:
- For your personal repositories: GET /user/repos?affiliation=owner.
- For an organization's repositories: GET /orgs/<org>/repos.
Iterate over each repository and use the following endpoints to collect more detailed data:
- GET /repos/<user_or_org>/<repository_name>: for general data about the repository.
- GET /repos/<repository_name>/pages: for data about the pages in the repository.

For members of an organization:

GET /orgs/<org>/members to list the members of the organization.
Iterate over each member and make a call to the GET /orgs/<org>/memberships/<member> endpoint to collect data on that user's association with the organization.

For teams within an organization:

GET /orgs/<org>/teams to list the organization's teams.
Iterate over each team and use the following endpoints to collect more detailed data:
- GET /orgs/<org>/teams/<team> for general team data.
- GET /orgs/<org>/teams/<team>/repos to list the team's repositories.
- GET /orgs/<org>/teams/<team>/members to list the members of that team. Iterate on each member of the team:
  - GET /orgs/<org>/teams/<team>/memberships/<member>

Now that you have all the data you need, just assign it to the respective resources in Pulumi:

Repository: github.Repository.
- Repository branch: github.Branch.
- Default branch (for unarchived repositories): github.BranchDefault.
Organization members: github.Membership.
Teams in the organization: github.Team.
- Team repositories: github.TeamRepository.
- For team members, you have two ways (I prefer the first because it's simpler):
  - github.TeamMembers.
  - github.TeamMembership.

Importing using repository

To abstract all this step-by-step data collection from GitHub and assembly of Pulumi resources that we saw earlier, I created the following repository:

alvarofpp / import-from-github-to-pulumi

Scripts to import resources from organizations and personal projects on GitHub into Pulumi.

Import from GitHub to Pulumi

This repository contains a configured Docker image with scripts to import your personal repositories or repositories, members and teams of an organization into Pulumi.

After running the import script, two sets of artifacts are generated and saved in the resources/:

import_*.txt: files with commands for importing resources.
members/*.ts, repositories/*.ts and teams/*.ts: Pulumi resource files.

The alvarofpp/template-infra-pulumi repository has a directory structure that you can use as a basis.

How to use

This repository can be used for two purposes:

Importing your personal repositories.
Importing members of an organization's repositories and teams.

For both cases, you first need to run make build to generate the Docker image that will be used to run the scripts.

The commands using make that will be shown below can be found in the Makefile file If you choose not to use the Makefile, you can…

View on GitHub

In this repository, you will have a Docker image configured and with scripts to generate the resource files for Pulumi based on the data returned by the GitHub API.

For this repository to work, you must have Docker and make installed on your machine. If you use Linux, you probably already have make installed.

⚠️ If you are importing accounts and organizations in sequence, after each import you can use the make clear command to clear the logs and files generated during the previous import.

In another directory, clone the repository:

git clone git@github.com:alvarofpp/import-from-github-to-pulumi.git

Generating personal repository files

Export the access token to GitHub:

export GITHUB_ACCESS_TOKEN=github_pat_...

Export your user on GitHub:
```
export GITHUB_USER=...
```
Run the command to generate the files for Pulumi:
```
make import-my-repos
```
In the resources directory you will find the following files:
- import_*.txt: file with the import commands.
- repositories/*.ts: files with the resources for each repository.

Generating the files of repositories, members and teams of an organization

Export the access token to GitHub:

export GITHUB_ACCESS_TOKEN=github_pat_...

Export the name of the organization on GitHub:
```
export GITHUB_ORG=...
```
Run the command to generate the files for Pulumi:
```
make import-org
```
In the resources directory you will find the following files:
- import_*.txt: file with the import commands.
- memberships/*.ts: files for each member of the organization.
- repositories/*.ts: files for each repository in the organization.
- teams/*.ts: files for each team in the organization.

Importing resources

If you have collected the data yourself, then you should also set up the import commands:

# Repository
pulumi import github:index/repository:Repository <resource_name> <repository>

# Branch of the repository
pulumi import github:index/branch:Branch <resource_name> <repository>:<branch>

# Organization member
pulumi import github:index/membership:Membership <resource_name> <org>:<member>

# Organization team
pulumi import github:index/team:Team <resource_name> <team_id>

# Team members
pulumi import github:index/teamMembers:TeamMembers <resource_name> <team_id>

# Team repository
pulumi import github:index/teamRepository:TeamRepository <resource_name> <team_id>:<repository>

If you have chosen to use the repository I suggested earlier, the step by step is:

Copy the *.ts files to their respective directories in the Pulumi project.
Execute all the commands in the import_*.txt files.
Now run pulumi up and apply the updates, if any.

That's it, you now have a project that allows you to manage your GitHub resources using Pulumi. Remember that this structure can be expanded to other types of resources and that you are using a programming language for this, so scripted automations work very well in this context.

Hints and tips

Note that we use the local Pulumi login, this is just to make it easier to teach. In a real environment, it is preferable that you save the states in S3 or a similar service.
The indentation of the codes may not be properly aligned, but you can use a formatter/linter to fix this. In my case, I use Deno's (deno fmt).

Use cases

There are several use cases and it depends on your context or the context of the organization. Here I'll list just a few use cases that are mainly useful for personal accounts.

Updating specific files

With the RepositoryFile feature you can manage specific files in your repositories. Examples of interesting files to use this feature are LICENSE and also workflows. This last type of file (workflows) is very useful for personal accounts, as GitHub allows you to share actions and workflows in organizations, but not in personal accounts.

Updating repositories for special occasions

I have some repositories that participate in Hacktoberfest. So I intend to put a date check so that every beginning of October I add the hacktoberfest topic to the repository and every beginning of November I remove that topic.

Sharing and access management

Now it's easier to define which accounts are part of your organization, their privileges, which teams have access to which repositories, etc.

Management of variables and secrets

If you use GitHub Actions, you should be familiar with the use of variables and secrets in your workflows. A good practice is to put a short expiration time on secrets and renew them whenever possible. Pulumi allows you to store secrets in the stack, the command to insert the GitHub token into the project is an example of this, so you can integrate this functionality with a token renewal script. Every time the script is run, it automatically updates the token in the stack and updates the secret in the repository.