Grant Curell's questions

Estou testando o Keycloak e queria integrá-lo ao OpenShift. Estou seguindo estas instruções

Cheguei onde você configura o escopo do cliente e o keycloak morre imediatamente com:

Instalação padrão, isso é tudo que fiz. Atualizar não faz nada. Para reproduzir basta ir em:

Clientes -> openshift (o nome do meu cliente) -> Escopos do cliente. Quando verifico os logs, vejo:

2024-07-15 19:32:02,456 ERROR [org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager] (executor-thread-27) Could not query server using DN [OU=Users,DC=openshift,DC=lan] and filter [(&(objectclass=person)(objectclass=organizationalPerson)(objectclass=user))]: javax.naming.NameNotFoundException: [LDAP: error code 32 - 0000208D: NameErr: DSID-0310028D, problem 2001 (NO_OBJECT), data 0, best match of:
        'DC=openshift,DC=lan'
]; remaining name 'OU=Users,DC=openshift,DC=lan'
        at java.naming/com.sun.jndi.ldap.LdapCtx.mapErrorCode(LdapCtx.java:3285)
        at java.naming/com.sun.jndi.ldap.LdapCtx.processReturnCode(LdapCtx.java:3206)
        at java.naming/com.sun.jndi.ldap.LdapCtx.processReturnCode(LdapCtx.java:2997)
        at java.naming/com.sun.jndi.ldap.LdapCtx.searchAux(LdapCtx.java:1876)
        at java.naming/com.sun.jndi.ldap.LdapCtx.c_search(LdapCtx.java:1799)
        at java.naming/com.sun.jndi.toolkit.ctx.ComponentDirContext.p_search(ComponentDirContext.java:392)
        at java.naming/com.sun.jndi.toolkit.ctx.PartialCompositeDirContext.search(PartialCompositeDirContext.java:358)
        at java.naming/javax.naming.directory.InitialDirContext.search(InitialDirContext.java:359)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager$3.execute(LDAPOperationManager.java:258)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager$3.execute(LDAPOperationManager.java:255)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager.execute(LDAPOperationManager.java:729)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager.execute(LDAPOperationManager.java:709)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager.execute(LDAPOperationManager.java:704)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPOperationManager.search(LDAPOperationManager.java:255)
        at org.keycloak.storage.ldap.idm.store.ldap.LDAPIdentityStore.fetchQueryResults(LDAPIdentityStore.java:278)
        at org.keycloak.storage.ldap.idm.query.internal.LDAPQuery.getResultList(LDAPQuery.java:174)
        at org.keycloak.storage.ldap.LDAPStorageProvider.paginatedSearchLDAP(LDAPStorageProvider.java:1123)
        at org.keycloak.storage.ldap.LDAPStorageProvider.searchLDAPByAttributes(LDAPStorageProvider.java:564)
        at org.keycloak.storage.ldap.LDAPStorageProvider.searchForUserStream(LDAPStorageProvider.java:379)
        at org.keycloak.storage.UserStorageManager.lambda$searchForUserStream$29(UserStorageManager.java:537)
        at org.keycloak.storage.UserStorageManager.lambda$query$13(UserStorageManager.java:331)
        at java.base/java.util.stream.ReferencePipeline$7$1.accept(ReferencePipeline.java:273)
        at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:179)
        at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:179)
        at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
        at java.base/java.util.ArrayList.forEach(ArrayList.java:1596)
        at java.base/java.util.stream.SortedOps$RefSortingSink.end(SortedOps.java:395)
        at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
        at java.base/java.util.stream.Sink$ChainedReference.end(Sink.java:261)
        at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:510)
        at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
        at java.base/java.util.stream.StreamSpliterators$WrappingSpliterator.forEachRemaining(StreamSpliterators.java:310)
        at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:735)
        at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:734)
        at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
        at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
        at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
        at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
        at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
        at java.base/java.util.stream.ReferencePipeline.forEachOrdered(ReferencePipeline.java:601)
        at com.fasterxml.jackson.datatype.jdk8.StreamSerializer.serialize(StreamSerializer.java:71)
        at com.fasterxml.jackson.datatype.jdk8.StreamSerializer.serialize(StreamSerializer.java:15)
        at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider._serialize(DefaultSerializerProvider.java:502)
        at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider.serializeValue(DefaultSerializerProvider.java:341)
        at com.fasterxml.jackson.databind.ObjectWriter$Prefetch.serialize(ObjectWriter.java:1574)
        at com.fasterxml.jackson.databind.ObjectWriter._writeValueAndClose(ObjectWriter.java:1275)
        at com.fasterxml.jackson.databind.ObjectWriter.writeValue(ObjectWriter.java:1098)
        at io.quarkus.resteasy.reactive.jackson.runtime.serialisers.FullyFeaturedServerJacksonMessageBodyWriter.writeResponse(FullyFeaturedServerJacksonMessageBodyWriter.java:79)
        at org.jboss.resteasy.reactive.server.core.ServerSerialisers.invokeWriter(ServerSerialisers.java:216)
        at org.jboss.resteasy.reactive.server.core.ServerSerialisers.invokeWriter(ServerSerialisers.java:184)
        at org.jboss.resteasy.reactive.server.core.serialization.FixedEntityWriter.write(FixedEntityWriter.java:28)
        at org.jboss.resteasy.reactive.server.handlers.ResponseWriterHandler.handle(ResponseWriterHandler.java:34)
        at io.quarkus.resteasy.reactive.server.runtime.QuarkusResteasyReactiveRequestContext.invokeHandler(QuarkusResteasyReactiveRequestContext.java:147)
        at org.jboss.resteasy.reactive.common.core.AbstractResteasyReactiveContext.run(AbstractResteasyReactiveContext.java:147)
        at io.quarkus.vertx.core.runtime.VertxCoreRecorder$14.runWith(VertxCoreRecorder.java:582)
        at org.jboss.threads.EnhancedQueueExecutor$Task.run(EnhancedQueueExecutor.java:2513)
        at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1538)
        at org.jboss.threads.DelegatingRunnable.run(DelegatingRunnable.java:29)
        at org.jboss.threads.ThreadLocalResettingRunnable.run(ThreadLocalResettingRunnable.java:29)
        at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
        at java.base/java.lang.Thread.run(Thread.java:1583)

mas até onde eu sei, isso está correto com base na configuração do AD do meu laboratório:

Em seguida, uma verificação final de integridade na configuração do LDAP:

Não tenho certeza do que o Keycloak está procurando aqui. Tudo está configurado corretamente.

BLUF : Como funciona a implementação do RAID5/6 no VMWare?

Abaixo está o gráfico da VMWare para RAID5/6 em vSAN :

Parece que o VMWare está alterando a terminologia do RAID. Quando ouço RAID6 penso em duas paridades de alguma coisa; normalmente duas unidades de paridade e posteriormente podemos tolerar duas falhas. Estou tendo problemas para entender este gráfico por alguns motivos:

• Qual é a diferença na linha 2/4 entre RAID5 e 6? Eles parecem ser idênticos.
• Por que o RAID 1 (espelhamento) é listado duas vezes, mas com diferentes falhas de tolerância e diferentes capacidades necessárias? Parece que cópias adicionais dos dados devem ser feitas, mas se for esse o caso, então não seria RAID1 (pelo menos não como eu entendo RAID1)
• Como é que eles têm um RAID6 que só tem uma única falha para tolerar

Enquanto escrevia a pergunta acima, percebi que o que isso pode significar é que eles estão executando um RAID6 com o FTT do VMWare definido como 1. No entanto, se for esse o caso, como isso funciona? Como eles estão obtendo dados de 100 GB com 133 GB necessários?

Estou em um cenário estranho onde tenho um servidor com back-end NodeJS e front-end ReactJS que mantém registros onde o cliente deseja usar certificados de usuário para identificar quem visita este site interno. O problema é que eles têm uma rede muito grande, com PKI complicado, e o certificado público que recebi para atribuir ao site não corresponde necessariamente a todos os clientes que podem visitá-lo.

Eu tenho nginx na frente com o ssl_verify_client optional_no_ca;conjunto, mas notei que os navegadores só darão aos usuários a opção de selecionar seu certificado de cliente se tiverem um certificado devidamente assinado pela mesma CA da chave pública apresentada pelo nginx.

Meu entendimento é que, durante a solicitação do certificado, o servidor pode especificar quais CAs são aceitáveis. Parece que o nginx pode estar fazendo isso, mas não tenho certeza se é esse o caso. Meu plano é começar a dissecar com o wireshark amanhã. Existe uma maneira conhecida de fazer meu site solicitar aos navegadores que sempre solicitem aos usuários um certificado de cliente? Talvez eu tenha entendido mal alguma coisa ao longo do caminho?

Tenho lido sobre RoCE e fala sobre transferir dados zero copy entre a memória de um servidor diretamente para a memória de uma aplicação em outro servidor. A maioria dos artigos faz questão de dizer que isso é feito sem envolvimento da CPU. Eu não entendo como isso é feito embora. Como os dados vão do adaptador para a RAM sem nenhum processamento da CPU? Como ele sabe onde os dados do aplicativo estão na RAM?

Geralmente estou trabalhando em software e sou fraco em armazenamento. Estou lendo sobre armazenamento de bloco versus arquivo versus armazenamento de objetos e tudo o que encontro fala sobre armazenamento como um assunto totalmente isolado, em vez de incluir o que o sistema operacional veria - que é o que realmente me interessa.

O que me confunde é a ideia de que o armazenamento de blocos e arquivos são completamente separados. Por exemplo, no LVM, você precisa fornecer dispositivos de bloco para gerenciar e, além disso, você tem os respectivos VGs e LVs com um sistema de arquivos em cima disso. Esses dispositivos de bloco não são considerados armazenamento em bloco?

Quando uma pessoa de armazenamento diz armazenamento de arquivos, esse armazenamento de arquivos em algum momento não necessariamente tem armazenamento em bloco embaixo dele? Por outro lado, o armazenamento em bloco não exigiria algo em cima dele para ser útil? Ou um sistema de arquivos ou algum tipo de armazenamento de objeto/proprietário/molho especial?

Por exemplo, se entendi corretamente, uma SAN tem algum tipo de controlador que apresenta LUNs (normalmente) que são montados por servidores (vistos como outro disco rígido no sistema operacional) que colocam sistemas de arquivos neles. Ou isso está incorreto?

Parece estranho porque a maior parte do material de leitura apresenta essas opções aparentemente mutuamente exclusivas e não tenho certeza se estou entendendo mal algo fundamental.

Estou muito interessado na otimização do meu trabalho e estou tentando entender melhor como selecionar as quantidades de RAM. Da minha leitura:

Para a mesma velocidade de memória DDR4 e tipo de DIMM, mais classificações normalmente aumentarão a latência carregada. Embora mais classificações no canal forneçam ao controlador de memória uma capacidade maior de paralelizar o processamento de solicitações de memória e reduzir o tamanho das filas de solicitações, ele também exige que o controlador emita mais comandos de atualização. Os benefícios de maior paralelização superam a penalidade dos ciclos de atualização adicionais até quatro níveis. O resultado líquido é uma ligeira redução nas latências carregadas para duas a quatro classificações em um canal. Com mais de quatro ranks em um canal, há um pequeno aumento na latência carregada. Fonte da citação: Útil para obter a definição de "rank".

Posteriormente, se eu quiser reduzir a latência de carga, acho que quero de duas a quatro classificações na minha RAM. No entanto, como você sabe quantos ranks algo é?

Por exemplo, se eu comprar RDIMMs de 32 GB, como posso saber quantos ranks essa RAM tem?

Atualização : Para qualquer outra pessoa que precise fazer isso: entrei na ferramenta de pesquisa de peças da minha empresa e consegui extrair as informações. Isso me deu esta string: "DIMM,32GB;2933,2RX4,8G,DDR4,R". Este post é útil para entender essa saída. O 2RX4 significa 2 fileiras de 4, cada uma com 8 GB de tamanho. Se você estiver apenas procurando comercialmente, poderá pesquisar pelo número da peça se estiver usando Newegg ou algo assim.