Provisionner une instance

5)Provisionner une instance

Cette section explique comment provisionner votre instance Oracle Blockchain Platform à l'aide de Blockchain Platform Manager.

Avant de créer une instance Oracle Blockchain Platform

Avant de provisionner Oracle Blockchain Platform, déterminez si une instance de développeur ou d'entreprise répond à vos besoins.

Choisir la forme de provisionnement à utiliser

Lors du provisionnement d'une instance, vous avez le choix entre deux configurations. La migration entre ces options n'est pas prise en charge actuellement.

Configuration	Fonctionnalités
Développeur L'utilisation recommandée pour cette forme de départ est le développement et l'évaluation.	1 noeud Fabric-CA Réseau de service de commande Fabric à 3 noeuds Référentiel à 1 noeud pour les métadonnées d'instance conteneurs d'exécution de code chaîne gérés de manière dynamique Service de console pour l'interface utilisateur Web des opérations Service proxy REST pour l'API RESTful Intégration du serveur LDAP pour l'authentification et la gestion des rôles
Entreprise Configuration d'instance hautement disponible, avec un nombre de répliques plus élevé pour chaque service.	3 noeuds Fabric CA Réseau de service de commande Fabric à 3 noeuds Référentiel de cluster à 3 noeuds pour la haute disponibilité des métadonnées d'instance Conteneur d'exécution de code chaîne géré de manière dynamique Service de console pour l'interface utilisateur Web des opérations Plusieurs répliques pour le service proxy REST pour l'API RESTful Intégration du serveur LDAP pour l'authentification et la gestion des rôles

Configuration

Fonctionnalités

Développeur

L'utilisation recommandée pour cette forme de départ est le développement et l'évaluation.

1 noeud Fabric-CA
Réseau de service de commande Fabric à 3 noeuds
Référentiel à 1 noeud pour les métadonnées d'instance
conteneurs d'exécution de code chaîne gérés de manière dynamique
Service de console pour l'interface utilisateur Web des opérations
Service proxy REST pour l'API RESTful
Intégration du serveur LDAP pour l'authentification et la gestion des rôles

Entreprise

Configuration d'instance hautement disponible, avec un nombre de répliques plus élevé pour chaque service.

3 noeuds Fabric CA
Réseau de service de commande Fabric à 3 noeuds
Référentiel de cluster à 3 noeuds pour la haute disponibilité des métadonnées d'instance
Conteneur d'exécution de code chaîne géré de manière dynamique
Service de console pour l'interface utilisateur Web des opérations
Plusieurs répliques pour le service proxy REST pour l'API RESTful
Intégration du serveur LDAP pour l'authentification et la gestion des rôles

Provisionner une instance à l'aide du gestionnaire de plate-forme Blockchain

Pour créer un fondateur de blockchain ou une instance de participant dans Blockchain Platform Manager, utilisez l'assistant Créer une instance.

Vous pouvez provisionner deux types d'instance Oracle Blockchain Platform :

Organisation fondatrice : environnement de chaîne de blocs complet, comprenant un nouveau réseau que les participants peuvent rejoindre plus tard.
Instance de participant : pour rejoindre une organisation fondatrice existante, vous pouvez créer une instance de participant si vos informations d'identification vous donnent accès au réseau. Notez qu'un participant ne peut pas fonctionner seul.

Dans Blockchain Platform Manager, ouvrez la page Instances.
Sélectionnez Créer une instance.

Renseignez les champs suivants :

Champ	Description
Nom d'instance	Entrez le nom de l'instance Oracle Blockchain Platform. Le nom de l'instance de service : doit contenir au moins un caractère, ne doit pas dépasser 15 caractères, doit commencer par une lettre ASCII (`a` à `z`), Ne doit contenir que des lettres ou des chiffres ASCII. ne doit pas contenir de trait d'union, ne doit pas contenir d'autres caractères spéciaux, doit être unique au sein du domaine d'identité.
Description	Facultatif. Entrez une brève description de l'instance Oracle Blockchain Platform.
Nom de domaine	Entrez le nom de domaine du cluster. Les noms d'hôte générés pour les services d'instance de chaîne de blocs utilisent respectivement le nom de domaine et le nom d'instance en tant que domaine parent et sous-domaine.
Rôle	Sélectionnez Fondateur pour créer un environnement de chaîne de blocs complet. Cette instance devient l'organisation fondatrice et vous pourrez intégrer de nouveaux participants au réseau plus tard. Sélectionnez Participant pour créer une instance qui rejoindra un réseau de chaîne de blocs existant créé ailleurs avant que cette instance puisse être utilisée.
Configuration	Sélectionnez une forme de provisionnement qui répond aux besoins de votre déploiement : Développeur Entreprise
Homologues	Indiquez le nombre de noeuds homologues à créer initialement dans cette instance de service. Vous pouvez créer des noeuds homologues supplémentaires dans la console Oracle Blockchain Platform ultérieurement.

Cliquez sur Créer une instance.

Provisionner les prérequis

Avant d'accéder à la console de service Oracle Blockchain Platform, configurez la résolution de nom d'hôte pour les services d'instance de chaîne de blocs, comme vous l'avez fait précédemment pour les noms d'hôte Blockchain Platform Manager. Utilisez la commande suivante pour obtenir la liste des noms d'hôte de l'instance de chaîne de blocs créée :

kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]

kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]

Une fois que vous avez créé une instance Oracle Blockchain Platform Enterprise Edition, vous devez configurer DNS afin que les noms d'hôte publics des composants puissent être résolus à partir du réseau local OpenShift.

Une fois l'instance créée, le nom de l'instance et le domaine parent sont utilisés en tant que sous-domaine pour les composants Oracle Blockchain Platform Enterprise Edition. Vous devez configurer le transfert DNS sur la configuration DNS par défaut pour OpenShift, de sorte que les demandes DNS soient transmises au pod DNS personnalisé sur lequel les services exposés sont résolus. Pour configurer le transfert DNS, procédez comme suit :

Exécutez la commande suivante .
```
oc new-project obp-coredns
```

Déployez un serveur coredns personnalisé dans l'espace de noms obp-coredns en exécutant la commande suivante.

kubectl apply -f <coredns-deployment-yaml-file>

Utilisez le fichier manifeste suivant avec la commande.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: obp-coredns
data:
  Corefile: |-
    .:1053 {
      errors
      health {
        lameduck 5s
      }
      ready
      kubernetes cluster.local in-addr.arpa ip6.arpa {
        pods insecure
        fallthrough in-addr.arpa ip6.arpa
      }
      prometheus :9153
      forward . /etc/resolv.conf
      cache 30
      loop
      reload
      loadbalance
    }
    import custom/*.server
 
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: obp-coredns
  strategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: obp-coredns
    spec:
      containers:
      - args:
        - -conf
        - /etc/coredns/Corefile
        image: docker.io/coredns/coredns:latest
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 5
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 5
        name: coredns
        ports:
        - containerPort: 1053
          name: dns
          protocol: UDP
        - containerPort: 1053
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /etc/coredns
          name: config-volume
          readOnly: true
        - mountPath: /etc/coredns/custom
          name: custom-config-volume
          readOnly: true
      dnsPolicy: Default
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      serviceAccount: obp-coredns
      serviceAccountName: obp-coredns
      terminationGracePeriodSeconds: 30
      volumes:
      - configMap:
          defaultMode: 420
          items:
          - key: Corefile
            path: Corefile
          name: coredns
        name: config-volume
      - configMap:
          defaultMode: 420
          name: coredns-custom
          optional: true
        name: custom-config-volume
 
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  ports:
  - name: dns
    port: 53
    protocol: UDP
    targetPort: 1053
  - name: dns-tcp
    port: 53
    protocol: TCP
    targetPort: 1053
  - name: metrics
    port: 9153
    protocol: TCP
    targetPort: 9153
  selector:
    app: obp-coredns
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: obp-coredns
  namespace: obp-coredns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: obp-coredns
rules:
- apiGroups:
  - ""
  resources:
  - endpoints
  - services
  - pods
  - namespaces
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - discovery.k8s.io
  resources:
  - endpointslices
  verbs:
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: obp-coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: obp-coredns
subjects:
- kind: ServiceAccount
  name: obp-coredns
  namespace: obp-coredns

Créez un fichier coredns-custom-configmap au format YAML pour votre instance de chaîne de blocs.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    <instanceName>.<domain>:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.<instanceName>\.<domain>\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }

Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine transmis lors de la création de l'instance.

Exécutez la commande suivante pour appliquer l'objet ConfigMap personnalisé.
```
kubectl apply -f <coredns-custom-configmap-yaml-file>
```
Exécutez la commande suivante pour obtenir l'adresse IP du cluster. Enregistrez l'adresse IP.
```
kubectl get svc -n obp-coredns
```
Exécutez la commande suivante pour modifier la ressource personnalisée DNS OpenShift.
```
kubectl edit dnses.operator/default
```
Mettez à jour la section des zones de la ressource personnalisée DNS pour utiliser votre instance et vos noms de domaine, comme indiqué dans l'exemple suivant.
```
## Add the following section to the dns custom resource under spec
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - <instanceName>.<domain>
```
Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.

Pour ajouter de nouvelles instances, ajoutez des entrées au fichier coredns-custom-configmap et mettez à jour la ressource personnalisée DNS OpenShift pour le domaine de la nouvelle instance, comme indiqué dans l'exemple suivant :

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    myobp.example.com:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.myobp\.example\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
 
    otherobp.example.org:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.otherobp\.example\.org istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }



## Edit the Openshift's DNS custom resource
kubectl edit dnses.operator/default
 
## Add the new instance domain to the existing .spec.servers.zones
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - myobp.example.com
    - otherobp.example.org

Vous devez arrêter et redémarrer l'instance Blockchain Platform à l'aide de Blockchain Platform Manager pour que les modifications DNS prennent effet.

Configurer le DNS

Exécutez la commande suivante .
```
oc new-project obp-coredns
```

Déployez un serveur coredns personnalisé dans l'espace de noms obp-coredns en exécutant la commande suivante.

kubectl apply -f <coredns-deployment-yaml-file>

Utilisez le fichier manifeste suivant avec la commande.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: obp-coredns
data:
  Corefile: |-
    .:1053 {
      errors
      health {
        lameduck 5s
      }
      ready
      kubernetes cluster.local in-addr.arpa ip6.arpa {
        pods insecure
        fallthrough in-addr.arpa ip6.arpa
      }
      prometheus :9153
      forward . /etc/resolv.conf
      cache 30
      loop
      reload
      loadbalance
    }
    import custom/*.server
 
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: obp-coredns
  strategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: obp-coredns
    spec:
      containers:
      - args:
        - -conf
        - /etc/coredns/Corefile
        image: docker.io/coredns/coredns:latest
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 5
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 5
        name: coredns
        ports:
        - containerPort: 1053
          name: dns
          protocol: UDP
        - containerPort: 1053
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        readinessProbe:
          failureThreshold: 3
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /etc/coredns
          name: config-volume
          readOnly: true
        - mountPath: /etc/coredns/custom
          name: custom-config-volume
          readOnly: true
      dnsPolicy: Default
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      serviceAccount: obp-coredns
      serviceAccountName: obp-coredns
      terminationGracePeriodSeconds: 30
      volumes:
      - configMap:
          defaultMode: 420
          items:
          - key: Corefile
            path: Corefile
          name: coredns
        name: config-volume
      - configMap:
          defaultMode: 420
          name: coredns-custom
          optional: true
        name: custom-config-volume
 
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: obp-coredns
  name: obp-coredns
  namespace: obp-coredns
spec:
  ports:
  - name: dns
    port: 53
    protocol: UDP
    targetPort: 1053
  - name: dns-tcp
    port: 53
    protocol: TCP
    targetPort: 1053  
  - name: metrics
    port: 9153
    protocol: TCP
    targetPort: 9153
  selector:
    app: obp-coredns
  sessionAffinity: None
  type: ClusterIP
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: obp-coredns
  namespace: obp-coredns
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: obp-coredns
rules:
- apiGroups:
  - ""
  resources:
  - endpoints
  - services
  - pods
  - namespaces
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - discovery.k8s.io
  resources:
  - endpointslices
  verbs:
  - list
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: obp-coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: obp-coredns
subjects:
- kind: ServiceAccount
  name: obp-coredns
  namespace: obp-coredns

Créez un fichier coredns-custom-configmap au format YAML pour votre instance de chaîne de blocs.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    <instanceName>.<domain>:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.<instanceName>\.<domain>\ istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }

Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.

Exécutez la commande suivante pour appliquer l'objet ConfigMap personnalisé.
```
kubectl apply -f <coredns-custom-configmap-yaml-file>
```
Exécutez la commande suivante pour obtenir l'adresse IP du cluster. Enregistrez l'adresse IP.
```
kubectl get svc -n obp-coredns
```
Exécutez la commande suivante pour modifier la ressource personnalisée DNS OpenShift.
```
kubectl edit dnses.operator/default
```
Mettez à jour la section des zones de la ressource personnalisée DNS pour utiliser votre instance et vos noms de domaine, comme indiqué dans l'exemple suivant.
```
## Add the following section to the dns custom resource under spec
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - <instanceName>.<domain>
```
Dans l'exemple précédent, <instanceName> est le nom de l'instance et <domain> est le domaine parent.

apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns-custom
  namespace: obp-coredns
data:
  obp.server: |2
 
    myobp.example.com:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.myobp\.example\.com istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }
 
    otherobp.example.org:1053 {
        log
        kubernetes cluster.local in-addr.arpa ip6.arpa {
            pods insecure
            fallthrough in-addr.arpa ip6.arpa
        }
        rewrite stop {
            name regex (.*)\.otherobp\.example\.org istio-ingressgateway.istio-system.svc.cluster.local answer auto
        }
        forward . /etc/resolv.conf
    }



## Edit the Openshift's DNS custom resource
kubectl edit dnses.operator/default
 
## Add the new instance domain to the existing .spec.servers.zones
  servers:
  - forwardPlugin:
      policy: Random
      upstreams:
      - 192.0.2.233
    name: obp-server
    zones:
    - myobp.example.com
    - otherobp.example.org

Vous devez arrêter et redémarrer l'instance pour que les modifications DNS prennent effet.

kubectl get virtualservice -n <instance-namespace> -o json | jq -r
      .items[].spec.hosts[0]

Ajouter des noeuds supplémentaires au cluster

La création de l'instance peut échouer en raison d'un nombre insuffisant de noeuds dans le cluster. Si cela se produit, vous devrez peut-être ajouter d'autres noeuds au cluster.

Exécutez la commande suivante pour rechercher les pods à l'état En attente :
```
kubectl get pods -n <instancename> | grep Pending
```
De plus, vous pouvez vérifier qu'aucun pod n'est disponible :
```
kubectl get pods -n instancename
```
Vérifiez ensuite les noeuds de processus actif disponibles :
```
kubectl get nodes | grep worker
```
Pour vérifier si des noeuds sont disponibles pour accepter de nouveaux pods, exécutez la commande suivante sur chaque noeud de processus actif :
```
kubectl describe node $<worker_node>
```
où <worker_node> est le nom d'un noeud de processus actif. Assurez-vous que la capacité du noeud de processus actif ne dépasse pas 100 %.
Pour ajouter des noeuds supplémentaires, commencez par obtenir le nombre de MachineSets dans le cluster :
```
oc get machinesets -n openshift-machine-api
```
Pour toute MachineSets comportant moins de 2 noeuds, essayez de les mettre à l'échelle.
```
oc scale --replicas=2 machineset <obpee00-qtthx-worker-eastus2> -n openshift-machine-api
```
où <obpee00-qtthx-worker-eastus2> est un exemple de nom MachineSet que vous voulez mettre à l'échelle jusqu'à 2 noeuds.
Interrogez à nouveau MachineSets jusqu'à ce que la liste des noeuds prêts et disponibles atteigne le nombre de noeuds que vous avez sélectionnés.
Vous pouvez désormais redéployer les instances en échec.

Une fois l'instance créée et répertoriée dans la liste Instances, vous pouvez lancer la console de service à partir du menu en regard du nom de l'instance. Utilisez la console pour configurer votre réseau comme décrit dans Qu'est-ce que la console ? dans Utilisation d'Oracle Blockchain Platform.