Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Risoluzione dei problemi relativi ai lavori che utilizzano PersistentVolumeClaims (PVC)
Se devi creare, elencare o eliminare PersistentVolumeClaims (PVC) per un lavoro ma non aggiungi le autorizzazioni PVC al ruolo Kubernetes predefinito *emr-containers*, il lavoro fallisce quando lo invii. Senza queste autorizzazioni, il ruolo *emr-containers* non può creare i ruoli necessari per il driver Spark o il client Spark. Non è sufficiente aggiungere autorizzazioni ai ruoli driver o client Spark, come suggerito dai messaggi di errore. Il ruolo primario *emr-containers* deve includere anche le autorizzazioni richieste. In questa sezione viene descritto come aggiungere le autorizzazioni richieste al ruolo primario *emr-containers*.
## Verifica
Per verificare se il tuo ruolo *emr-containers* dispone delle autorizzazioni necessarie, imposta la variabile NAMESPACE con il tuo valore e quindi esegui il seguente comando:
```
export NAMESPACE=YOUR_VALUE
kubectl describe role emr-containers -n ${NAMESPACE}
```
Inoltre, per verificare se i ruoli Spark e client dispongono delle autorizzazioni necessarie, esegui il seguente comando:
```
kubectl describe role emr-containers-role-spark-driver -n ${NAMESPACE}
kubectl describe role emr-containers-role-spark-client -n ${NAMESPACE}
```
Se le autorizzazioni non sono disponibili, procedi con la patch, come segue.
## Patch
1. Se i processi senza le autorizzazioni sono attualmente in esecuzione, arrestarli.
1. Crea un file denominato *RBAC\_Patch.py* come segue:
```
import os
import subprocess as sp
import tempfile as temp
import json
import argparse
import uuid
def delete_if_exists(dictionary: dict, key: str):
if dictionary.get(key, None) is not None:
del dictionary[key]
def doTerminalCmd(cmd):
with temp.TemporaryFile() as f:
process = sp.Popen(cmd, stdout=f, stderr=f)
process.wait()
f.seek(0)
msg = f.read().decode()
return msg
def patchRole(roleName, namespace, extraRules, skipConfirmation=False):
cmd = f"kubectl get role {roleName} -n {namespace} --output json".split(" ")
msg = doTerminalCmd(cmd)
if "(NotFound)" in msg and "Error" in msg:
print(msg)
return False
role = json.loads(msg)
rules = role["rules"]
rulesToAssign = extraRules[::]
passedRules = []
for rule in rules:
apiGroups = set(rule["apiGroups"])
resources = set(rule["resources"])
verbs = set(rule["verbs"])
for extraRule in extraRules:
passes = 0
apiGroupsExtra = set(extraRule["apiGroups"])
resourcesExtra = set(extraRule["resources"])
verbsExtra = set(extraRule["verbs"])
passes += len(apiGroupsExtra.intersection(apiGroups)) >= len(apiGroupsExtra)
passes += len(resourcesExtra.intersection(resources)) >= len(resourcesExtra)
passes += len(verbsExtra.intersection(verbs)) >= len(verbsExtra)
if passes >= 3:
if extraRule not in passedRules:
passedRules.append(extraRule)
if extraRule in rulesToAssign:
rulesToAssign.remove(extraRule)
break
prompt_text = "Apply Changes?"
if len(rulesToAssign) == 0:
print(f"The role {roleName} seems to already have the necessary permissions!")
prompt_text = "Proceed anyways?"
for ruleToAssign in rulesToAssign:
role["rules"].append(ruleToAssign)
delete_if_exists(role, "creationTimestamp")
delete_if_exists(role, "resourceVersion")
delete_if_exists(role, "uid")
new_role = json.dumps(role, indent=3)
uid = uuid.uuid4()
filename = f"Role-{roleName}-New_Permissions-{uid}-TemporaryFile.json"
try:
with open(filename, "w+") as f:
f.write(new_role)
f.flush()
prompt = "y"
if not skipConfirmation:
prompt = input(
doTerminalCmd(f"kubectl diff -f {filename}".split(" ")) + f"\n{prompt_text} y/n: "
).lower().strip()
while prompt != "y" and prompt != "n":
prompt = input("Please make a valid selection. y/n: ").lower().strip()
if prompt == "y":
print(doTerminalCmd(f"kubectl apply -f {filename}".split(" ")))
except Exception as e:
print(e)
os.remove(f"./{filename}")
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("-n", "--namespace",
help="Namespace of the Role. By default its the VirtualCluster's namespace",
required=True,
dest="namespace"
)
parser.add_argument("-p", "--no-prompt",
help="Applies the patches without asking first",
dest="no_prompt",
default=False,
action="store_true"
)
args = parser.parse_args()
emrRoleRules = [
{
"apiGroups": [""],
"resources": ["persistentvolumeclaims"],
"verbs": ["list", "create", "delete", "patch"]
}
]
driverRoleRules = [
{
"apiGroups": [""],
"resources": ["persistentvolumeclaims"],
"verbs": ["list", "create", "delete", "patch", "deletecollection"]
},
{
"apiGroups": [""],
"resources": ["services"],
"verbs": ["get", "list", "describe", "create", "delete", "watch", "deletecollection"]
},
{
"apiGroups": [""],
"resources": ["configmaps", "pods"],
"verbs": ["deletecollection"]
}
]
clientRoleRules = [
{
"apiGroups": [""],
"resources": ["persistentvolumeclaims"],
"verbs": ["list", "create", "delete", "patch"]
}
]
patchRole("emr-containers", args.namespace, emrRoleRules, args.no_prompt)
patchRole("emr-containers-role-spark-driver", args.namespace, driverRoleRules, args.no_prompt)
patchRole("emr-containers-role-spark-client", args.namespace, clientRoleRules, args.no_prompt)
```
1. Esegui lo script Python:
```
python3 RBAC_Patch.py -n ${NAMESPACE}
```
1. Viene visualizzata una differenza kubectl tra le nuove autorizzazioni e quelle vecchie. Premi y per applicare la patch al ruolo.
1. Verifica i tre ruoli con autorizzazioni aggiuntive come segue:
```
kubectl describe role -n ${NAMESPACE}
```
1. Esegui lo script python:
```
python3 RBAC_Patch.py -n ${NAMESPACE}
```
1. Dopo aver eseguito il comando, verrà visualizzata una differenza kubectl tra le nuove autorizzazioni e quelle vecchie. Premi y per applicare la patch al ruolo.
1. Verifica i tre ruoli con autorizzazioni aggiuntive:
```
kubectl describe role -n ${NAMESPACE}
```
1. Invia nuovamente il processo.
## Patch manuale
Se l'autorizzazione richiesta dalla tua applicazione si applica a qualcosa di diverso dalle regole PVC, puoi aggiungere manualmente le autorizzazioni Kubernetes per il tuo cluster virtuale Amazon EMR secondo necessità.
**Nota**
Il ruolo *emr-containers* è un ruolo primario. Ciò significa che deve fornire tutte le autorizzazioni necessarie prima di poter modificare i ruoli driver o client sottostanti.
1. Scarica le autorizzazioni attuali nei file yaml eseguendo i comandi seguenti:
```
kubectl get role -n ${NAMESPACE} emr-containers -o yaml >> emr-containers-role-patch.yaml
kubectl get role -n ${NAMESPACE} emr-containers-role-spark-driver -o yaml >> driver-role-patch.yaml
kubectl get role -n ${NAMESPACE} emr-containers-role-spark-client -o yaml >> client-role-patch.yaml
```
1. In base all'autorizzazione richiesta dalla tua applicazione, modifica ogni file e aggiungi regole aggiuntive come le seguenti:
+ emr-containers-role-patch.yaml
```
- apiGroups:
- ""
resources:
- persistentvolumeclaims
verbs:
- list
- create
- delete
- patch
```
+ driver-role-patch.yaml
```
- apiGroups:
- ""
resources:
- persistentvolumeclaims
verbs:
- list
- create
- delete
- patch
- deletecollection
- apiGroups:
- ""
resources:
- services
verbs:
- get
- list
- describe
- create
- delete
- watch
- deletecollection
- apiGroups:
- ""
resources:
- configmaps
- pods
verbs:
- deletecollection
```
+ client-role-patch.yaml
```
- apiGroups:
- ""
resources:
- persistentvolumeclaims
verbs:
- list
- create
- delete
- patch
```
1. Rimuovi i seguenti attributi con i relativi valori. Ciò è necessario per applicare l'aggiornamento.
+ creationTimestamp
+ resourceVersion
+ uid
1. Infine, esegui la patch:
```
kubectl apply -f emr-containers-role-patch.yaml
kubectl apply -f driver-role-patch.yaml
kubectl apply -f client-role-patch.yaml
```