CORs, JWT über Cookie mit httponly übertragen ⇐ Python

[Guest]

Problem :
Wenn ich ein JWT -Token über Cookies direkt an http: // localhost: 8000/api/profile sende, funktioniert es einwandfrei, und ich Empfange Benutzer Daten. Wenn ich das Token jedoch über einen zweiten Microservice übergebenin Zweiter Microservice:

Code: Select all

{
"status": 401,
"statusText": "Unauthorized",
"headers": {
"date": "Sat, 22 Feb 2025 08:03:25 GMT",
"server": "uvicorn",
"content-length": "29",
"content-type": "application/json"
},
"data": {
"detail": "Token is missing"
}
}

CORS-Einstellungen für den Microservice, der das Token sendet

Code: Select all

app.set('trust proxy', true);
app.use(cookieParser());

// CORS settings
app.use(cors({
origin: 'http://localhost:5173',
credentials: true,
optionsSuccessStatus: 200
}));

CORS-Einstellungen für den Microservice, der das Token erhält [/b]:

Code: Select all

app = FastAPI()

origins = [
"http://localhost:5173"
]

app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)

Code zum Senden von Cookies :

Code: Select all

const axios = require('axios');

const getUserProfile = async (token) => {
try {
const response = await axios.get('http://fast-api:8000/api/profile', {
withCredentials: true,  // Send cookies with the request
});
return response.data;
} catch (error) {
console.error('Error fetching user profile:', error);

if (error.response) {
console.error('Response error data:', error.response.data);
console.error('Response error status:', error.response.status);
console.error('Response error headers:', error.response.headers);
} else if (error.request) {
console.error('Request error data:', error.request);
} else {
console.error('General error message:', error.message);
}

throw new Error('Failed to fetch user profile');
}
};

Middleware Authorization :

Code: Select all

const authMiddleware = async (req, res, next) => {
const token = req.cookies.access_token;

console.log('Cookies:', req.cookies);
console.log('Received token:', token);

if (!token) {
return res.status(401).json({message: 'Token is missing'});
}

try {
const userProfile = await getUserProfile(token);
req.user = userProfile;
next();
} catch (error) {
console.error('Error in authMiddleware:', error);
return res.status(401).json({
message: error.message,
stack: error.stack,
});
}
};

Code zum Empfangen des Tokens in Fastapi :

Code: Select all

@router.get("/profile")
def get_user(request: Request):
print("Received headers:", request.headers)
print("Received query parameters:", request.query_params)
print("Received cookies:", request.cookies)

token = request.cookies.get("access_token")
print("Received token:", token)
if not token:
raise HTTPException(status_code=401, detail="Token is missing")

return get_user_service(token)
< /code>

 Ausgabe < /strong>:
Die Protokolle aus dem Senden von MicroService zeigen, dass die Cookies korrekt empfangen werden, aber wenn sie werden vom empfangenden Microservice verarbeitet, das Token wird nicht gefunden und ein 401 nicht autorisierter 

Fehler zurückgegeben.
Was könnte das Problem beim Senden des Tokens sein auf diese Weise zwischen Microservices? Warum wird das Token in der Anfrage nicht korrekt an den zweiten Microservice übergeben?