uaa Download - uaa download do código-fonte

uaa

Outro código-fonte

77.19.0

Baixar

Folga #uaa

Servidor de conta de usuário e autenticação (UAA) do CloudFoundry

O UAA é um serviço de gerenciamento de identidade multilocatário, usado no Cloud Foundry, mas também disponível como um servidor OAuth2 independente. Sua função principal é como provedor OAuth2, emitindo tokens para aplicativos clientes usarem quando agem em nome de usuários do Cloud Foundry. Ele também pode autenticar usuários com suas credenciais do Cloud Foundry e atuar como um serviço SSO usando essas credenciais (ou outras). Possui endpoints para gerenciamento de contas de usuários e para registro de clientes OAuth2, além de diversas outras funções de gerenciamento.

Servidor UAA

O serviço de autenticação é uaa . É um webapp simples do Spring MVC. Implante normalmente no Tomcat ou no contêiner de sua escolha ou execute ./gradlew run para executá-lo diretamente do diretório uaa na árvore de origem. Ao executar com gradle ele escuta na porta 8080 e a URL é http://localhost:8080/uaa

O Servidor UAA suporta as APIs definidas no documento UAA-APIs. Para resumir:

Os pontos de extremidade /oauth/authorize e /oauth/token do OAuth2
Um endpoint /login_info para permitir a consulta de prompts de login necessários
Um endpoint /check_token, para permitir que servidores de recursos obtenham informações sobre um token de acesso enviado por um cliente OAuth2.
Um endpoint /token_key, para permitir que os servidores de recursos obtenham a chave de verificação para verificar assinaturas de token
Ponto de extremidade de provisionamento de usuário SCIM
Terminais de conexão OpenID para suportar autenticação /userinfo. Suporte parcial para OpenID.

A autenticação pode ser realizada por clientes de linha de comando enviando credenciais diretamente para o endpoint /oauth/authorize (conforme descrito no documento UAA-API). Existe um ImplicitAccessTokenProvider no Spring Security OAuth que pode fazer o trabalho pesado se o seu cliente for Java.

Casos de uso

Autenticar
```
 GET /login
```
Uma interface de login de formulário básico.
Aprovar concessão de token OAuth2
```
 GET /oauth/authorize?client_id=app&response_type=code...
```
Endpoint de autorização OAuth2 padrão.
Obter token de acesso
```
 POST /oauth/token
```
Endpoint de autorização OAuth2 padrão.

Coordenadas

Tokens: uma nota sobre tokens, escopos e autoridades
Fórum técnico: lista de discussão cf-dev
Documentos: documentos/
Documentação da API: http://docs.cloudfoundry.org/api/uaa/
Especificação: A estrutura principal do OpenID Connect, incluindo a estrutura de autorização Oauth 2
LDAP: Integração LDAP UAA

Início rápido

Requisitos:

Java 17

Se isso funcionar, você está no negócio:

 $ git clone git://github.com/cloudfoundry/uaa.git
$ cd uaa
$ ./gradlew run

Todos os aplicativos funcionam juntos com os aplicativos executados na mesma porta (8080) que /uaa , /app e /api .

O UAA registrará em um arquivo chamado uaa.log que pode ser encontrado usando o seguinte comando: –

 $ sudo lsof | grep uaa.log

que você deve encontrar em algo como: -

 $TMPDIR/cargo/conf/logs/

Demonstração do uso da linha de comando no servidor local

Primeiro execute o servidor UAA conforme descrito acima:

 $ ./gradlew run

De outro terminal você pode usar curl para verificar se o UAA foi iniciado solicitando informações do sistema:

 $ curl --silent --show-error --head localhost:8080/uaa/login | head -1
HTTP/1.1 200

Para solicitações complexas é mais conveniente interagir com o UAA usando uaac , o cliente de linha de comando do UAA.

Depurando servidor local

Para carregar o agente JDWP para depuração jvm UAA, inicie o servidor da seguinte maneira:

./gradlew run -Dxdebug=true

ou

./gradlew -Dspring.profiles.active=default,hsqldb,debug run

Você pode então anexar seu depurador à porta 5005 do processo jvm.

Para suspender a inicialização do servidor até que o depurador seja conectado (útil para depurar o código de inicialização), inicie o servidor da seguinte maneira:

./gradlew run -Dxdebugs=true

ou

./gradlew -Dspring.profiles.active=default,hsqldb,debugs run

Executando servidor UAA local com bancos de dados diferentes

./gradlew run executa o servidor UAA com banco de dados hsqldb por padrão.

MySQL

Inicie o servidor mysql (por exemplo, um contêiner docker mysql)

% docker run --name mysql1 -e MYSQL_ROOT_PASSWORD=changeme -d -p3306:3306 mysql

Crie o banco de dados uaa (por exemplo, na sessão interativa mysql)

% mysql -h 127.0.0.1 -u root -p
...
mysql > create database uaa ;

Execute o servidor UAA com o perfil mysql

% ./gradlew -Dspring.profiles.active=mysql,default run

PostgreSQL

Inicie o servidor postgresql (por exemplo, um contêiner docker postgres)

docker run --name postgres1 -p 5432:5432 -e POSTGRES_PASSWORD=mysecretpassword -d postgres

Crie o banco de dados uaa (por exemplo, na sessão interativa psql)

% psql -h 127.0.0.1 -U postgres

 create database uaa;
create user root with superuser password 'changeme';

Execute o servidor UAA com o perfil postgresql

% ./gradlew -Dspring.profiles.active=postgresql,default run

Assim que o servidor UAA for iniciado, você poderá ver as tabelas criadas no banco de dados uaa (por exemplo, na sessão interativa psql)

 c uaa
psql (14.5 (Homebrew), server 15.0 (Debian 15.0-1.pgdg110+1))
WARNING: psql major version 14, server major version 15.
         Some psql features might not work.
You are now connected to database "uaa" as user "postgres".
d
List of relations
 Schema |             Name              |   Type   | Owner
--------+-------------------------------+----------+-------
 public | authz_approvals               | table    | root
 public | expiring_code_store           | table    | root
 public | external_group_mapping        | table    | root
 public | external_group_mapping_id_seq | sequence | root
 public | group_membership              | table    | root
 public | group_membership_id_seq       | sequence | root
 public | groups                        | table    | root
 public | identity_provider             | table    | root
 public | identity_zone                 | table    | root
 public | oauth_client_details          | table    | root
 public | oauth_code                    | table    | root
 public | oauth_code_id_seq             | sequence | root
 public | revocable_tokens              | table    | root
 public | schema_version                | table    | root
 public | sec_audit                     | table    | root
 public | sec_audit_id_seq              | sequence | root
 public | spring_session                | table    | root
 public | spring_session_attributes     | table    | root
 public | user_info                     | table    | root
 public | users                         | table    | root
(23 rows)

Executando testes

Você pode executar os testes de integração com docker

 $ run-integration-tests.sh <dbtype>

criará um contêiner docker executando o banco de dados uaa + ldap + no qual os testes de integração serão executados.

Usando Gradle para testar com postgresql ou mysql

Os testes de unidade uaa padrão (./gradlew test IntegrationTest) usam hsqldb.

Para executar os testes de unidade com o docker:

 $ run-unit-tests.sh <dbtype>

Para executar um único teste

Os testes de unidade uaa padrão ( ./gradlew test ) usam hsqldb.

Comece descobrindo a qual projeto Gradle seu teste pertence. Você pode encontrar todos os projetos executando

 $ ./gradlew projects

Para executar uma classe de teste específica, você pode especificar o módulo e a classe de teste.

 $ ./gradlew :<project name>:test --tests <TestClass>.<MethodName>

Neste exemplo, ele está executando apenas os testes JdbcScimGroupMembershipManagerTests no módulo cloudfoundry-identity-server:

 $ ./gradlew :cloudfoundry-identity-server:test 
--tests "org.cloudfoundry.identity.uaa.scim.jdbc.JdbcScimGroupMembershipManagerTests"

ou para executar todos os testes em uma classe

 $ ./gradlew :<project name>:test --tests <TestClass>

Você pode querer usar o comando gradle completo encontrado na parte inferior do script scripts/unit-tests.sh acrescentando o nome do projeto ao comando test e adicionando a opção --tests .

Construindo arquivo de guerra

 $ ./gradlew :clean :assemble -Pversion=${UAA_VERSION}

Inventário

Na verdade, existem vários projetos aqui, o aplicativo principal do servidor uaa , uma biblioteca cliente e alguns exemplos:

uaa um projeto WAR para fácil implantação
server um projeto JAR contendo a implementação da API REST do UAA (incluindo SCIM) e UI
model um projeto JAR usado pela biblioteca cliente e pelo servidor
api (amostra) é um serviço de recurso OAuth2 que retorna uma lista simulada de aplicativos implantados
app (amostra) é um aplicativo de usuário que usa ambos os itens acima

Nos termos do CloudFoundry

uaa fornece um serviço de autenticação além de delegação autorizada para serviços e aplicativos de back-end (emitindo tokens de acesso OAuth2).
api é um serviço que fornece recursos que outros aplicativos podem desejar acessar em nome do proprietário do recurso (o usuário final).
app é um webapp que precisa de logon único e acesso ao serviço api em nome dos usuários.

Executando o UAA no Kubernetes

Pré-requisitos

ano, testado com 0.24.0
kubectl

A implantação do Kubernetes está em desenvolvimento ativo. Você deve esperar mudanças frequentes (e possivelmente significativas). Esta seção será atualizada à medida que houver progresso neste conjunto de recursos. A partir de agora:

O diretório K8s contém modelos ytt que podem ser renderizados e aplicados a um cluster K8s.

No desenvolvimento, este Makefile pode ser usado para atividades comuns de renderização e implantação.

Na produção, você provavelmente desejará usar o ytt diretamente. Algo assim deve ajudar você:

$ ytt -f templates -f values/default-values.yml | kubectl apply -f -

Se quiser substituir alguns desses valores, você pode fazer isso aproveitando a funcionalidade de sobreposição do YTT.

$ ytt -f templates -f values/default-values.yml -f your-dir/production-values.yml | kubectl apply -f -

Claro, você sempre pode abandonar completamente os valores padrão e fornecer seu próprio arquivo de valores.

Contribuindo para a UAA

Aqui estão algumas maneiras de você se envolver na comunidade:

Junte-se ao uaa no Slack #uaa
Crie tickets no github para bugs e novos recursos e comente e vote naqueles que lhe interessam.
Github é para codificação social: se você deseja escrever código, incentivamos contribuições por meio de pull requests de forks deste repositório. Se você quiser contribuir com código dessa forma, faça referência a um problema existente, se houver, que também cubra o problema específico que você está abordando. Sempre envie solicitações pull para o branch "develop". Aderimos estritamente ao desenvolvimento orientado a testes. Pedimos gentilmente que as solicitações pull sejam acompanhadas de casos de teste que falhariam se executados separadamente da solicitação pull.
Depois de criar a solicitação pull, você mesmo pode verificar as métricas do código
nas ações do Github e no Sonar. A meta para o novo código deve ser quase 100% testado e código limpo:

Conectando UAA ao servidor LDAP local

Requisitos:

Docker
Composição do Docker

Para depurar integrações UAA e LDAP, usamos uma imagem docker OpenLdap do projeto Bitnami da VMWare

Modifique o arquivo uaa/src/main/resources/uaa.yml e habilite o LDAP removendo o comentário da linha 7, spring_profiles: ldap,default,hsqldb
execute docker-compose up no diretório scripts/ldap
De scripts/ldap verifique a conectividade até a execução do contêiner OpenLdap executando docker-confirm-ldapquery.sh
Inicie o UAA com ./gradlew run
Navegue para /uaa e faça login com o usuário LDAP user01 e senha password1